FINERACT-1760: Raise transaction replayed business event

fineract-provider/src/test/java/org/apache/fineract/cob/COBBusinessStepServiceStepDefinitions.java

@@ -22,6 +22,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 import com.google.common.base.Splitter;
 import io.cucumber.java8.En;
@@ -39,6 +40,7 @@ import org.apache.fineract.infrastructure.core.domain.ActionContext;
 import org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
 import org.apache.fineract.infrastructure.event.business.service.BusinessEventNotifierService;
 import org.apache.fineract.mix.data.MixTaxonomyData;
+import org.mockito.Mockito;
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.context.ApplicationContext;
@@ -147,6 +149,14 @@ public class COBBusinessStepServiceStepDefinitions implements En {
             ThreadLocalContextUtil.setActionContext(ActionContext.DEFAULT);
         });
 
+        Then("throw exception COBBusinessStepService.run method with verification", () -> {
+            assertThrows(BusinessStepException.class, () -> {
+                resultItem = this.businessStepService.run(this.executionMap, this.item);
+            });
+            verify(businessEventNotifierService, Mockito.times(1)).resetEventRecording();
+            ThreadLocalContextUtil.setActionContext(ActionContext.DEFAULT);
+        });
+
         Then("The COBBusinessStepService.getCOBBusinessStepMap result exception", () -> {
             assertThrows(BeanCreationException.class, () -> {
                 this.businessStepService.getCOBBusinessStepMap(this.clazz, this.jobName);

fineract-provider/src/test/java/org/apache/fineract/cob/common/InitialisationTaskletStepDefinitions.java

@@ -24,6 +24,8 @@ import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
 
 import io.cucumber.java8.En;
+import org.apache.fineract.infrastructure.core.domain.ActionContext;
+import org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
 import org.apache.fineract.useradministration.domain.AppUser;
 import org.apache.fineract.useradministration.domain.AppUserRepositoryWrapper;
 import org.springframework.batch.repeat.RepeatStatus;
@@ -56,12 +58,14 @@ public class InitialisationTaskletStepDefinitions implements En {
         Then("InitialisationTasklet.execute result should match", () -> {
             assertEquals(RepeatStatus.FINISHED, resultItem);
             assertEquals(appUser, SecurityContextHolder.getContext().getAuthentication().getPrincipal());
+            ThreadLocalContextUtil.setActionContext(ActionContext.DEFAULT);
         });
 
         Then("throw exception InitialisationTasklet.execute method", () -> {
             assertThrows(RuntimeException.class, () -> {
                 resultItem = this.initialisationTasklet.execute(null, null);
             });
+            ThreadLocalContextUtil.setActionContext(ActionContext.DEFAULT);
         });
     }
 }

fineract-provider/src/test/java/org/apache/fineract/portfolio/loanaccount/service/ReplayedTransactionBusinessEventServiceIntegrationTest.java

@@ -0,0 +1,140 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.fineract.portfolio.loanaccount.service;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.verify;
+
+import java.util.Optional;
+import org.apache.fineract.infrastructure.event.business.domain.loan.LoanAdjustTransactionBusinessEvent;
+import org.apache.fineract.infrastructure.event.business.service.BusinessEventNotifierService;
+import org.apache.fineract.portfolio.loanaccount.domain.ChangedTransactionDetail;
+import org.apache.fineract.portfolio.loanaccount.domain.LoanTransaction;
+import org.apache.fineract.portfolio.loanaccount.domain.LoanTransactionRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class ReplayedTransactionBusinessEventServiceIntegrationTest {
+
+    @Mock
+    private BusinessEventNotifierService businessEventNotifierService;
+
+    @Mock
+    private LoanTransactionRepository loanTransactionRepository;
+
+    private ReplayedTransactionBusinessEventService underTest;
+
+    @BeforeEach
+    public void setUp() {
+        underTest = new ReplayedTransactionBusinessEventServiceImpl(businessEventNotifierService, loanTransactionRepository);
+    }
+
+    @Test
+    public void testWhenParamIsNull() {
+        // given
+        ChangedTransactionDetail changedTransactionDetail = null;
+        // when
+        underTest.raiseTransactionReplayedEvents(changedTransactionDetail);
+        // then
+        verify(businessEventNotifierService, Mockito.times(0)).startExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(0))
+                .notifyPostBusinessEvent(Mockito.any(LoanAdjustTransactionBusinessEvent.class));
+        verify(businessEventNotifierService, Mockito.times(0)).stopExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(0)).resetEventRecording();
+    }
+
+    @Test
+    public void testWhenParamHasNoMapping() {
+        // given
+        ChangedTransactionDetail changedTransactionDetail = new ChangedTransactionDetail();
+        // when
+        underTest.raiseTransactionReplayedEvents(changedTransactionDetail);
+        // then
+        verify(businessEventNotifierService, Mockito.times(0)).startExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(0))
+                .notifyPostBusinessEvent(Mockito.any(LoanAdjustTransactionBusinessEvent.class));
+        verify(businessEventNotifierService, Mockito.times(0)).stopExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(0)).resetEventRecording();
+    }
+
+    @Test
+    public void testWhenParamHasOneNewTransaction() {
+        // given
+        LoanTransaction oldLoanTransaction = Mockito.mock(LoanTransaction.class);
+        LoanTransaction newLoanTransaction = Mockito.mock(LoanTransaction.class);
+        lenient().when(loanTransactionRepository.findById(1L)).thenReturn(Optional.of(oldLoanTransaction));
+        ChangedTransactionDetail changedTransactionDetail = new ChangedTransactionDetail();
+        changedTransactionDetail.getNewTransactionMappings().put(1L, newLoanTransaction);
+        // when
+        underTest.raiseTransactionReplayedEvents(changedTransactionDetail);
+        // then
+        verify(businessEventNotifierService, Mockito.times(1)).startExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(1))
+                .notifyPostBusinessEvent(Mockito.any(LoanAdjustTransactionBusinessEvent.class));
+        verify(businessEventNotifierService, Mockito.times(1)).stopExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(0)).resetEventRecording();
+    }
+
+    @Test
+    public void testWhenParamHasTwoNewTransaction() {
+        // given
+        LoanTransaction oldLoanTransaction = Mockito.mock(LoanTransaction.class);
+        LoanTransaction newLoanTransaction = Mockito.mock(LoanTransaction.class);
+        lenient().when(loanTransactionRepository.findById(1L)).thenReturn(Optional.of(oldLoanTransaction));
+        lenient().when(loanTransactionRepository.findById(2L)).thenReturn(Optional.of(oldLoanTransaction));
+        ChangedTransactionDetail changedTransactionDetail = new ChangedTransactionDetail();
+        changedTransactionDetail.getNewTransactionMappings().put(1L, newLoanTransaction);
+        changedTransactionDetail.getNewTransactionMappings().put(2L, newLoanTransaction);
+        // when
+        underTest.raiseTransactionReplayedEvents(changedTransactionDetail);
+        // then
+        verify(businessEventNotifierService, Mockito.times(1)).startExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(2))
+                .notifyPostBusinessEvent(Mockito.any(LoanAdjustTransactionBusinessEvent.class));
+        verify(businessEventNotifierService, Mockito.times(1)).stopExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(0)).resetEventRecording();
+    }
+
+    @Test
+    public void testWhenParamHasError() {
+        // given
+        doThrow(new RuntimeException()).when(businessEventNotifierService)
+                .notifyPostBusinessEvent(Mockito.any(LoanAdjustTransactionBusinessEvent.class));
+        LoanTransaction oldLoanTransaction = Mockito.mock(LoanTransaction.class);
+        LoanTransaction newLoanTransaction = Mockito.mock(LoanTransaction.class);
+        lenient().when(loanTransactionRepository.findById(1L)).thenReturn(Optional.of(oldLoanTransaction));
+        ChangedTransactionDetail changedTransactionDetail = new ChangedTransactionDetail();
+        changedTransactionDetail.getNewTransactionMappings().put(1L, newLoanTransaction);
+        // when
+        assertThrows(RuntimeException.class, () -> underTest.raiseTransactionReplayedEvents(changedTransactionDetail));
+        // then
+        verify(businessEventNotifierService, Mockito.times(1)).startExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(1))
+                .notifyPostBusinessEvent(Mockito.any(LoanAdjustTransactionBusinessEvent.class));
+        verify(businessEventNotifierService, Mockito.times(0)).stopExternalEventRecording();
+        verify(businessEventNotifierService, Mockito.times(1)).resetEventRecording();
+    }
+}

fineract-provider/src/test/resources/features/cob/cob.feature

@@ -37,6 +37,14 @@ Feature: COB
     Examples:
       |executionMap|
       |null|
+
+  @cob
+  Scenario Outline: COB Business Step Service - run test failure
+    Given The COBBusinessStepService.run method with executeMap <executionMap>
+    Then throw exception COBBusinessStepService.run method with verification
+
+    Examples:
+      |executionMap|
       |2,notExist|
       |3,|