Enhance ProfileImportIT test and clean up unnecessary code

Updated the ProfileImportIT test case by adding budget verification and enabling the import of user profiles with budgets. Removed unused mock settings from ProcessTestExtension and added budget-related mock settings in RuntimeContext. These changes provide a more comprehensive test coverage and a cleaner codebase.

Author: gjong

bpmn-process/src/test/java/com/jongsoft/finance/bpmn/ProfileImportIT.java

@@ -4,6 +4,7 @@
 import com.jongsoft.finance.bpmn.process.RuntimeContext;
 import com.jongsoft.finance.core.RuleColumn;
 import com.jongsoft.finance.domain.account.Account;
+import com.jongsoft.finance.domain.user.Budget;
 import com.jongsoft.lang.collection.Sequence;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.DisplayName;
@@ -100,7 +101,8 @@ void runWithTags(RuntimeContext context) {
 
         context
             .verifyTagCreated("cat")
-            .verifyTagCreated("dog");
+            .verifyTagCreated("dog")
+            .verifyTagCreated("charity");
     }
 
     @Test
@@ -166,15 +168,31 @@ void runWithTransactions(RuntimeContext context) {
                             }));
     }
 
-//    @Test
-//    @DisplayName("Import a profile with budgets")
-//    void runWithBudgets(RuntimeContext context) {
-//        context
-//            .withStorage()
-//            .withStorage("my-sample-token", "/profile-test/budget-only.json");
-//
-//        context.execute("ImportUserProfile", Map.of(
-//                "storageToken", "my-sample-token"))
-//                .verifyCompleted();
-//    }
+    @Test
+    @DisplayName("Import a profile with budgets")
+    @SuppressWarnings("unchecked")
+    void runWithBudgets(RuntimeContext context) {
+        context
+            .withBudgets()
+            .withStorage()
+            .withStorage("my-sample-token", "/profile-test/budget-only.json");
+        context.execute("ImportUserProfile", Map.of(
+                "storageToken", "my-sample-token"))
+                .verifyCompleted();
+
+        context.verifyBudget(LocalDate.parse("2011-12-01"), budget -> {
+            budget.extracting("expectedIncome", "start")
+                    .containsExactlyInAnyOrder(2500D, LocalDate.parse("2011-12-01"));
+
+            budget.extracting("expenses")
+                    .satisfies(expenses -> {
+                        Assertions.assertThat((Sequence<Budget.Expense>) expenses)
+                                .extracting(Budget.Expense::getName)
+                                .containsExactlyInAnyOrder("Sparen", "Vervoer", "Abonnementen", "Huishoudelijke kosten", "Boodschappen");
+                    });
+        });
+        context.verifyBudget(LocalDate.parse("2012-12-01"), budget ->
+                budget.extracting("expectedIncome", "start")
+                        .containsExactlyInAnyOrder(3000D, LocalDate.parse("2012-12-01")));
+    }
 }

bpmn-process/src/test/java/com/jongsoft/finance/bpmn/process/ProcessTestExtension.java

@@ -1,25 +1,18 @@
 package com.jongsoft.finance.bpmn.process;
 
-import com.jongsoft.finance.messaging.EventBus;
 import io.micronaut.context.annotation.Property;
-import io.micronaut.context.event.ApplicationEventPublisher;
 import io.micronaut.core.annotation.Nullable;
 import io.micronaut.test.extensions.junit5.MicronautJunit5Extension;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.ParameterContext;
 import org.junit.jupiter.api.extension.ParameterResolutionException;
-import org.mockito.Mockito;
 
 import java.lang.reflect.AnnotatedElement;
 import java.util.List;
 import java.util.function.Consumer;
 
 public class ProcessTestExtension extends MicronautJunit5Extension {
 
-    static {
-        new EventBus(Mockito.mock(ApplicationEventPublisher.class));
-    }
-
     public interface ProcessExecution<T extends ProcessExecution> {
         ProcessExecution<?> obtainChildProcess(String processKey);
         T verifyCompleted();

bpmn-process/src/test/java/com/jongsoft/finance/bpmn/process/RuntimeContext.java

@@ -15,6 +15,8 @@
 import com.jongsoft.finance.domain.user.Role;
 import com.jongsoft.finance.domain.user.UserAccount;
 import com.jongsoft.finance.factory.FilterFactory;
+import com.jongsoft.finance.messaging.EventBus;
+import com.jongsoft.finance.messaging.commands.budget.CreateBudgetCommand;
 import com.jongsoft.finance.messaging.commands.transaction.CreateTransactionCommand;
 import com.jongsoft.finance.messaging.handlers.TransactionCreationHandler;
 import com.jongsoft.finance.providers.*;
@@ -24,6 +26,7 @@
 import com.jongsoft.lang.Control;
 import com.jongsoft.lang.control.Optional;
 import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.event.ApplicationEventPublisher;
 import io.micronaut.core.reflect.ReflectionUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.mutable.MutableLong;
@@ -36,23 +39,23 @@
 import org.mockito.stubbing.OngoingStubbing;
 
 import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
+import java.time.LocalDate;
+import java.util.*;
 import java.util.function.Consumer;
 
 @Slf4j
 public class RuntimeContext {
 
     private ApplicationContext applicationContext;
+    private ApplicationEventPublisher applicationEventPublisher;
 
     private ProcessEngine processEngine;
 
     private UserAccount userAccount;
 
     private final List<String> storageTokens;
     private final MutableLong idGenerator;
+    private final List<Budget> registeredBudgets;
 
     public RuntimeContext(ApplicationContext applicationContext) {
         this.applicationContext = applicationContext;
@@ -64,14 +67,17 @@ public RuntimeContext(ApplicationContext applicationContext) {
                 .roles(Collections.List(new Role("admin")))
                 .build());
         this.processEngine = applicationContext.getBean(ProcessEngine.class);
+        this.applicationEventPublisher = Mockito.spy(applicationContext.getBean(ApplicationEventPublisher.class));
         idGenerator = new MutableLong(100);
+        registeredBudgets = new ArrayList<>();
 
         setupDefaultMocks();
     }
 
     void clean() {
         processEngine.close();
         storageTokens.clear();
+        registeredBudgets.clear();
     }
 
     public RuntimeContext withStorage() {
@@ -98,6 +104,34 @@ public RuntimeContext withStorage(String token, String resource) {
         return this;
     }
 
+    @SuppressWarnings("unchecked")
+    public RuntimeContext withBudgets() {
+        var budgetProvider = applicationContext.getBean(BudgetProvider.class);
+        Mockito.when(budgetProvider.lookup(Mockito.anyInt(), Mockito.anyInt()))
+                .thenAnswer(invocation -> {
+                    var date = LocalDate.of(invocation.getArgument(0), invocation.getArgument(1, Integer.class), 1);
+
+                    return Control.Option(registeredBudgets.stream()
+                            .filter(budget -> budget.getStart().isBefore(date) || budget.getStart().isEqual(date))
+                            .max(Comparator.comparing(Budget::getStart))
+                            .orElse(null));
+                });
+
+        Mockito.doAnswer((Answer<Void>) invocation -> {
+                    var createCommand = invocation.getArgument(0, CreateBudgetCommand.class);
+
+                    var budget = Budget.builder()
+                            .start(createCommand.budget().getStart())
+                            .expectedIncome(createCommand.budget().getExpectedIncome())
+                            .id(idGenerator.getAndIncrement())
+                            .expenses(Collections.List())
+                            .build();
+                    registeredBudgets.add(budget);
+                    return null;
+                }).when(applicationEventPublisher).publishEvent(Mockito.any(CreateBudgetCommand.class));
+        return this;
+    }
+
     public RuntimeContext withBudget(int year, int month, Budget budget) {
         var budgetProvider = applicationContext.getBean(BudgetProvider.class);
         Mockito.when(budgetProvider.lookup(year, month))
@@ -232,12 +266,24 @@ public RuntimeContext verifyAccountCreated(String name, String currency, String
         return this;
     }
 
+    /**
+     * Verifies if a category with the specified name has been created.
+     *
+     * @param name the name of the category to be verified
+     * @return the current RuntimeContext instance
+     */
     public RuntimeContext verifyCategoryCreated(String name) {
         Mockito.verify(userAccount, Mockito.atMostOnce())
                 .createCategory(name);
         return this;
     }
 
+    /**
+     * Verifies the transactions by performing validations provided by the consumer.
+     *
+     * @param validations the consumer that accepts a ListAssert<Transaction> for performing validations
+     * @return the RuntimeContext instance
+     */
     public RuntimeContext verifyTransactions(Consumer<ListAssert<Transaction>> validations) {
         var createdTransactions = Mockito.mockingDetails(applicationContext.getBean(TransactionCreationHandler.class)).getInvocations().stream()
                 .filter(invocation -> invocation.getMethod().getName().equals("handleCreatedEvent"))
@@ -250,12 +296,34 @@ public RuntimeContext verifyTransactions(Consumer<ListAssert<Transaction>> valid
         return this;
     }
 
+    /**
+     * Verifies that all storage tokens have been cleaned.
+     *
+     * @return The RuntimeContext object.
+     */
     public RuntimeContext verifyStorageCleaned() {
         storageTokens.forEach(token ->
                 Mockito.verify(applicationContext.getBean(StorageService.class)).remove(token));
         return this;
     }
 
+    /**
+     * Verifies the budget for the specified start date.
+     *
+     * @param startDate the start date of the budget to verify
+     * @param validations the consumer function that performs assertions on the budget
+     * @return the current RuntimeContext object
+     */
+    public RuntimeContext verifyBudget(LocalDate startDate, Consumer<ObjectAssert<Budget>> validations) {
+        validations.accept(
+                Assertions.assertThat(registeredBudgets.stream()
+                                .filter(budget -> budget.getStart().equals(startDate))
+                                .findFirst()
+                                .orElseThrow(() -> new AssertionError("Budget not found for start date: " + startDate)))
+                        .as("Budget created for start date: " + startDate));
+        return this;
+    }
+
     public RuntimeContext verifyRuleCreated(String name, Consumer<ObjectAssert<TransactionRule>> validations) {
         var matchedRule = Mockito.mockingDetails(applicationContext.getBean(TransactionRuleProvider.class))
                 .getInvocations().stream()
@@ -282,6 +350,7 @@ public <T> T verifyInteraction(Class<T> type) {
 
     void resetMocks() {
         Mockito.reset(
+                applicationContext.getBean(BudgetProvider.class),
                 applicationContext.getBean(AuthenticationFacade.class),
                 applicationContext.getBean(CurrentUserProvider.class),
                 applicationContext.getBean(AccountProvider.class),
@@ -303,6 +372,8 @@ private void setupDefaultMocks() {
         Mockito.when(applicationContext.getBean(CurrentUserProvider.class).currentUser())
                 .thenReturn(userAccount);
 
+        new EventBus(applicationEventPublisher);
+
         // Prepare the mocks for the filter factory
         var filterFactory = applicationContext.getBean(FilterFactory.class);
         Mockito.when(filterFactory.account()).thenReturn(Mockito.mock(AccountProvider.FilterCommand.class, Mockito.RETURNS_DEEP_STUBS));