feat: first approach for event tests (#166)

* feat: first approach for event tests

* feat: added accounthandler duplicate test

* chore: added postgres to gha

* chore: merged build with tests and sonar gha

* chore: removed tests from earthly build

* chore: removed tests from earthly build

* chore: add tests for resource

* chore: add tests for resource

* feat: add duplicate tests for blockchain publisher events

Author: Kammerlo

.github/workflows/build-with-tests.yaml

@@ -32,10 +32,19 @@ jobs:
 
       - name: Test
         run: |
-         ./gradlew clean test
+         ./gradlew clean test jacocoTestReport
       - name: Spotless
         run : |
           ./gradlew spotlessCheck
+      - name: SonarCloud Scan
+        env:
+          SONAR_TOKEN: ${{ secrets.SONARCLOUD_TOKEN }}
+        run: |
+          ./gradlew sonar \
+          -Dsonar.host.url=https://sonarcloud.io \
+          -Dsonar.organization=cardano-foundation \
+          -Dsonar.projectKey=cardano-foundation_cf-lob-platform \
+          -Dsonar.branch.name=${{ github.head_ref }}
 
 #  mutation-test:
 #    needs: test

.github/workflows/sonar-cloud-report.yml

@@ -1,7 +1,7 @@
 FROM openjdk:21-jdk-slim AS build
 WORKDIR /app
 COPY . /app
-RUN ./gradlew clean build publishMavenJavaPublicationToLocalM2Repository
+RUN ./gradlew clean build publishMavenJavaPublicationToLocalM2Repository -x test
 
 FROM scratch AS platform-library-m2-cache
 COPY --from=build /root/.m2 /root/.m2

Dockerfile

@@ -10,4 +10,10 @@ dependencies {
     implementation(project(":blockchain_reader"))
     implementation(project(":organisation"))
     implementation(project(":support"))
+
+    testImplementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    testImplementation("org.springframework.modulith:spring-modulith-starter-test")
+    testImplementation("org.springframework.modulith:spring-modulith-starter-core")
+    testImplementation("org.springframework.modulith:spring-modulith-events-jdbc")
+    testImplementation("org.springframework.boot:spring-boot-starter-validation")
 }

accounting_reporting_core/build.gradle.kts

@@ -87,7 +87,8 @@ public String getId() {
             @AttributeOverride(name = "transactionInternalNumber", column = @Column(name = "transaction_internal_number", nullable = false)),
             @AttributeOverride(name = "transactionEntryDate", column = @Column(name = "transaction_entry_date", nullable = false)),
             @AttributeOverride(name = "transactionType", column = @Column(name = "transaction_type", nullable = false)),
-            @AttributeOverride(name = "amountLcySum", column = @Column(name = "amount_lcy_sum", nullable = false))
+            @AttributeOverride(name = "amountLcySum", column = @Column(name = "amount_lcy_sum", nullable = false)),
+            @AttributeOverride(name = "sourceDiff", column = @Column(name = "source_diff", nullable = false))
     })
     @Setter
     @Getter

accounting_reporting_core/src/main/java/org/cardanofoundation/lob/app/accounting_reporting_core/domain/entity/reconcilation/ReconcilationEntity.java

@@ -62,8 +62,12 @@ public void createReconcilation(String reconcilationId,
                         " to: {}",
                 reconcilationId, from, to
         );
-
-        val reconcilationEntity = new ReconcilationEntity();
+        Optional<ReconcilationEntity> entity = transactionReconcilationRepository.findById(reconcilationId);
+        if(entity.isPresent()) {
+            log.warn("Reconcilation already exists, reconcilationId: {}", reconcilationId);
+            return;
+        }
+        ReconcilationEntity reconcilationEntity = new ReconcilationEntity();
         reconcilationEntity.setId(reconcilationId);
         reconcilationEntity.setOrganisationId(organisationId);
         reconcilationEntity.setStatus(ReconcilationStatus.CREATED);

accounting_reporting_core/src/main/java/org/cardanofoundation/lob/app/accounting_reporting_core/service/internal/TransactionReconcilationService.java

@@ -0,0 +1,29 @@
+package org.cardanofoundation.lob.app.accounting_reporting_core.config;
+
+import java.math.BigDecimal;
+
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import org.javers.core.Javers;
+import org.javers.core.JaversBuilder;
+
+import org.cardanofoundation.lob.app.support.javers.LOBBigDecimalComparator;
+
+@Configuration
+@Slf4j
+public class JaversConfig {
+
+    @Bean
+    public Javers javers() {
+        log.info("Creating Javers diff instance...");
+
+        return JaversBuilder.javers()
+                .withPrettyPrint(true)
+                .registerValue(BigDecimal.class, new LOBBigDecimalComparator())
+                .build();
+    }
+
+}

accounting_reporting_core/src/test/java/org/cardanofoundation/lob/app/accounting_reporting_core/config/JaversConfig.java

@@ -0,0 +1,23 @@
+package org.cardanofoundation.lob.app.accounting_reporting_core.config;
+
+import javax.sql.DataSource;
+
+import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
+
+@Configuration
+@EnableJpaRepositories( { "org.cardanofoundation.lob", "org.springframework.modulith.events.jpa" } )
+public class JpaConfig {
+
+    @Bean
+    public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder, DataSource dataSource) {
+        return builder
+                .dataSource(dataSource)
+                .packages("org.cardanofoundation.lob")
+                .persistenceUnit("default")
+                .build();
+    }
+}

accounting_reporting_core/src/test/java/org/cardanofoundation/lob/app/accounting_reporting_core/config/JpaConfig.java

@@ -0,0 +1,24 @@
+package org.cardanofoundation.lob.app.accounting_reporting_core.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.modulith.events.core.EventSerializer;
+
+@Configuration
+public class ModulithEventConfig {
+
+    @Bean
+    public EventSerializer eventSerializer() {
+        return new EventSerializer() {
+            @Override
+            public Object serialize(Object event) {
+                return null;
+            }
+
+            @Override
+            public <T> T deserialize(Object serialized, Class<T> type) {
+                return null;
+            }
+        };
+    }
+}

accounting_reporting_core/src/test/java/org/cardanofoundation/lob/app/accounting_reporting_core/config/ModulithEventConfig.java

@@ -0,0 +1,24 @@
+package org.cardanofoundation.lob.app.accounting_reporting_core.config;
+
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
+
+import lombok.extern.slf4j.Slf4j;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@Slf4j
+public class TimeConfig {
+
+    @Bean
+    public Clock clock() {
+        // Set the fixed instant and time zone
+        log.info("Setting fixed clock for testing...");
+        Instant fixedInstant = Instant.parse("2025-02-26T00:00:00.00Z");
+        ZoneId zoneId = ZoneId.of("UTC");
+        return Clock.fixed(fixedInstant, zoneId);
+    }
+}

accounting_reporting_core/src/test/java/org/cardanofoundation/lob/app/accounting_reporting_core/config/TimeConfig.java

@@ -0,0 +1,83 @@
+package org.cardanofoundation.lob.app.accounting_reporting_core.resource;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+import static org.zalando.problem.Status.BAD_REQUEST;
+
+import org.springframework.http.ResponseEntity;
+
+import io.vavr.control.Either;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.zalando.problem.Problem;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import org.cardanofoundation.lob.app.accounting_reporting_core.resource.presentation_layer_service.AccountingCorePresentationViewService;
+import org.cardanofoundation.lob.app.accounting_reporting_core.resource.requests.ReconciliationFilterRequest;
+import org.cardanofoundation.lob.app.accounting_reporting_core.resource.requests.ReconciliationRejectionCodeRequest;
+import org.cardanofoundation.lob.app.accounting_reporting_core.resource.requests.ReconciliationRequest;
+import org.cardanofoundation.lob.app.accounting_reporting_core.service.internal.AccountingCoreService;
+
+@ExtendWith(MockitoExtension.class)
+class AccountingCoreResourceReconciliationTest {
+
+    @Mock
+    private AccountingCorePresentationViewService accountingCorePresentationViewService;
+    @Mock
+    private AccountingCoreService accountingCoreService;
+
+    @InjectMocks
+    private AccountingCoreResourceReconciliation accountingCoreResourceReconciliation;
+
+    @Test
+    void testReconcileTriggerAction_successfull() {
+        when(accountingCoreService.scheduleReconcilation(any(), any(), any())).thenReturn(Either.right(null));
+        ResponseEntity<?> responseEntity = accountingCoreResourceReconciliation.reconcileTriggerAction(new ReconciliationRequest());
+        Assertions.assertEquals(200, responseEntity.getStatusCode().value());
+        verify(accountingCoreService).scheduleReconcilation(any(), any(), any());
+        verifyNoMoreInteractions(accountingCoreService);
+        verifyNoInteractions(accountingCorePresentationViewService);
+    }
+
+    @Test
+    void testReconcileTriggerAction_problem() {
+        when(accountingCoreService.scheduleReconcilation(any(), any(), any())).thenReturn(Either.left(Problem.builder()
+                .withTitle("title")
+                .withStatus(BAD_REQUEST)
+                .build()));
+        ResponseEntity<?> responseEntity = accountingCoreResourceReconciliation.reconcileTriggerAction(new ReconciliationRequest());
+
+        Assertions.assertEquals(400, responseEntity.getStatusCode().value());
+        verify(accountingCoreService).scheduleReconcilation(any(), any(), any());
+        verifyNoMoreInteractions(accountingCoreService);
+        verifyNoInteractions(accountingCorePresentationViewService);
+    }
+
+    @Test
+    void testReconcileStart() {
+        when(accountingCorePresentationViewService.allReconciliationTransaction(any())).thenReturn(null);
+        ResponseEntity<?> responseEntity = accountingCoreResourceReconciliation.reconcileStart(new ReconciliationFilterRequest(), 0, 10);
+        Assertions.assertEquals(200, responseEntity.getStatusCode().value());
+        verify(accountingCorePresentationViewService).allReconciliationTransaction(any());
+        verifyNoMoreInteractions(accountingCorePresentationViewService);
+        verifyNoInteractions(accountingCoreService);
+    }
+
+    @Test
+    void testReconciliationRejectionCode() {
+        ResponseEntity<?> responseEntity = accountingCoreResourceReconciliation.reconciliationRejectionCode();
+        Assertions.assertEquals(200, responseEntity.getStatusCode().value());
+        ReconciliationRejectionCodeRequest[] body = (ReconciliationRejectionCodeRequest[])responseEntity.getBody();
+        Assertions.assertNotNull(body);
+        Assertions.assertEquals(5, body.length);
+        verifyNoInteractions(accountingCoreService);
+        verifyNoInteractions(accountingCorePresentationViewService);
+    }
+}