feat: implement maker-checker for product creation, add app user preferences, and introduce base interest rate management services.

fineract-provider/src/test/java/org/apache/fineract/commands/service/CommandSourceServiceTest.java

@@ -28,6 +28,7 @@ import org.apache.fineract.batch.exception.ErrorInfo;
 import org.apache.fineract.commands.domain.CommandSource;
 import org.apache.fineract.commands.domain.CommandSourceRepository;
 import org.apache.fineract.commands.domain.CommandWrapper;
+import org.apache.fineract.commands.handler.NewCommandSourceHandler;
 import org.apache.fineract.infrastructure.codes.exception.CodeNotFoundException;
 import org.apache.fineract.infrastructure.configuration.domain.ConfigurationDomainService;
 import org.apache.fineract.infrastructure.core.api.JsonCommand;
@@ -113,4 +114,395 @@ public class CommandSourceServiceTest {
         Assertions.assertEquals(1001, result.getErrorCode());
         Assertions.assertTrue(result.getMessage().contains("Code with name `foo` does not exist"));
     }
+
+    @Test
+    public void testProcessCommand_NonGLAccount_SuperUser_BypassesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("WITHDRAW_SAVINGSACCOUNT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("SAVINGSACCOUNT");
+        Mockito.when(commandSource.getActionName()).thenReturn("WITHDRAW");
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("WITHDRAW_SAVINGSACCOUNT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult result = underTest.processCommand(handler, jsonCommand,
+                commandSource, superUser, false);
+
+        Assertions.assertNotNull(result);
+        Mockito.verify(commandSource).markAsChecked(superUser);
+        Mockito.verify(commandSource, Mockito.never()).markAsAwaitingApproval();
+    }
+
+    @Test
+    public void testProcessCommand_GLAccount_SuperUser_EnforcesMakerChecker_Create() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_GLACCOUNT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("GLACCOUNT");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(100L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(200L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_GLACCOUNT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_GLAccount_SuperUser_EnforcesMakerChecker_Update_And_Disable() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("UPDATE_GLACCOUNT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("GLACCOUNT");
+        Mockito.when(commandSource.getActionName()).thenReturn("UPDATE");
+        Mockito.when(commandSource.getId()).thenReturn(101L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(201L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("UPDATE_GLACCOUNT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_GLAccount_SuperUser_EnforcesMakerChecker_Delete() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("DELETE_GLACCOUNT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("GLACCOUNT");
+        Mockito.when(commandSource.getActionName()).thenReturn("DELETE");
+        Mockito.when(commandSource.getId()).thenReturn(102L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(202L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("DELETE_GLACCOUNT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_GLAccount_CheckerApproval_ExecutesSuccessfully() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser checkerUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("UPDATE_GLACCOUNT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("GLACCOUNT");
+        Mockito.when(commandSource.getActionName()).thenReturn("UPDATE");
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("UPDATE_GLACCOUNT")).thenReturn(true);
+        Mockito.when(checkerUser.isCheckerSuperUser()).thenReturn(false);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult result = underTest.processCommand(handler, jsonCommand,
+                commandSource, checkerUser, true);
+
+        Assertions.assertNotNull(result);
+        Mockito.verify(commandSource).markAsChecked(checkerUser);
+        Mockito.verify(commandSource, Mockito.never()).markAsAwaitingApproval();
+    }
+
+    @Test
+    public void testProcessCommand_GLAccount_NonSuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser regularUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_GLACCOUNT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("GLACCOUNT");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(103L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(203L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_GLACCOUNT")).thenReturn(true);
+        Mockito.when(regularUser.isCheckerSuperUser()).thenReturn(false);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, regularUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_CBSBaseInterestRate_SuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_CBSBASEINTERESTRATE");
+        Mockito.when(commandSource.getEntityName()).thenReturn("CBSBASEINTERESTRATE");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(104L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(204L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_CBSBASEINTERESTRATE")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_CBSBaseInterestRate_CheckerApproval_MarksAsChecked() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser checkerUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_CBSBASEINTERESTRATE");
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_CBSBASEINTERESTRATE")).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult result = underTest.processCommand(handler, jsonCommand,
+                commandSource, checkerUser, true);
+
+        Assertions.assertNotNull(result);
+        Mockito.verify(commandSource).markAsChecked(checkerUser);
+        Mockito.verify(commandSource, Mockito.never()).markAsAwaitingApproval();
+    }
+
+    @Test
+    public void testProcessCommand_Charge_SuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_CHARGE");
+        Mockito.when(commandSource.getEntityName()).thenReturn("CHARGE");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(105L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(205L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_CHARGE")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_Charge_NonSuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser regularUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_CHARGE");
+        Mockito.when(commandSource.getEntityName()).thenReturn("CHARGE");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(106L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(206L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_CHARGE")).thenReturn(true);
+        Mockito.when(regularUser.isCheckerSuperUser()).thenReturn(false);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, regularUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_LoanProduct_SuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_LOANPRODUCT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("LOANPRODUCT");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(110L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(210L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_LOANPRODUCT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_SavingsProduct_SuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_SAVINGSPRODUCT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("SAVINGSPRODUCT");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(111L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(211L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_SAVINGSPRODUCT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_CurrentProduct_SuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_CURRENTPRODUCT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("CURRENTPRODUCT");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(112L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(212L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_CURRENTPRODUCT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_ShareProduct_SuperUser_EnforcesMakerChecker() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser superUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_SHAREPRODUCT");
+        Mockito.when(commandSource.getEntityName()).thenReturn("SHAREPRODUCT");
+        Mockito.when(commandSource.getActionName()).thenReturn("CREATE");
+        Mockito.when(commandSource.getId()).thenReturn(113L);
+        Mockito.when(commandSource.getResourceId()).thenReturn(213L);
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_SHAREPRODUCT")).thenReturn(true);
+        Mockito.when(superUser.isCheckerSuperUser()).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        Assertions.assertThrows(org.apache.fineract.commands.exception.RollbackTransactionNotApprovedException.class, () -> {
+            underTest.processCommand(handler, jsonCommand, commandSource, superUser, false);
+        });
+
+        Mockito.verify(commandSource).markAsAwaitingApproval();
+        Mockito.verify(commandSource, Mockito.never()).markAsChecked(any());
+    }
+
+    @Test
+    public void testProcessCommand_Products_CheckerApproval_MarksAsChecked() {
+        NewCommandSourceHandler handler = Mockito.mock(NewCommandSourceHandler.class);
+        JsonCommand jsonCommand = Mockito.mock(JsonCommand.class);
+        CommandSource commandSource = Mockito.mock(CommandSource.class);
+        AppUser checkerUser = Mockito.mock(AppUser.class);
+
+        Mockito.when(commandSource.getPermissionCode()).thenReturn("CREATE_LOANPRODUCT");
+        Mockito.when(configurationDomainService.isMakerCheckerEnabledForTask("CREATE_LOANPRODUCT")).thenReturn(true);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult dummyResult = new org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder()
+                .withCommandId(1L).build();
+        Mockito.when(handler.processCommand(jsonCommand)).thenReturn(dummyResult);
+
+        org.apache.fineract.infrastructure.core.data.CommandProcessingResult result = underTest.processCommand(handler, jsonCommand,
+                commandSource, checkerUser, true);
+
+        Assertions.assertNotNull(result);
+        Mockito.verify(commandSource).markAsChecked(checkerUser);
+        Mockito.verify(commandSource, Mockito.never()).markAsAwaitingApproval();
+    }
 }

fineract-provider/src/test/java/org/apache/fineract/portfolio/charge/handler/CreateChargeDefinitionCommandHandlerTest.java

@@ -0,0 +1,60 @@
+/**
+ * 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.charge.handler;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder;
+import org.apache.fineract.portfolio.charge.service.ChargeWritePlatformService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class CreateChargeDefinitionCommandHandlerTest {
+
+    @Mock
+    private ChargeWritePlatformService writePlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @InjectMocks
+    private CreateChargeDefinitionCommandHandler underTest;
+
+    @Test
+    void shouldDelegateToWritePlatformServiceAndReturnResult() {
+        CommandProcessingResult expectedResult = new CommandProcessingResultBuilder()
+                .withCommandId(101L)
+                .withEntityId(201L)
+                .build();
+        when(writePlatformService.createCharge(command)).thenReturn(expectedResult);
+
+        CommandProcessingResult actualResult = underTest.processCommand(command);
+
+        verify(writePlatformService).createCharge(command);
+        assertEquals(expectedResult, actualResult);
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/loanproduct/handler/CreateLoanProductCommandHandlerTest.java

@@ -0,0 +1,60 @@
+/**
+ * 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.loanproduct.handler;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder;
+import org.apache.fineract.portfolio.loanproduct.service.LoanProductWritePlatformService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class CreateLoanProductCommandHandlerTest {
+
+    @Mock
+    private LoanProductWritePlatformService writePlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @InjectMocks
+    private CreateLoanProductCommandHandler underTest;
+
+    @Test
+    void shouldDelegateToWritePlatformServiceAndReturnResult() {
+        CommandProcessingResult expectedResult = new CommandProcessingResultBuilder()
+                .withCommandId(101L)
+                .withEntityId(201L)
+                .build();
+        when(writePlatformService.createLoanProduct(command)).thenReturn(expectedResult);
+
+        CommandProcessingResult actualResult = underTest.processCommand(command);
+
+        verify(writePlatformService).createLoanProduct(command);
+        assertEquals(expectedResult, actualResult);
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/savings/handler/CreateCbsBaseInterestRateCommandHandlerTest.java

@@ -0,0 +1,60 @@
+/**
+ * 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.savings.handler;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder;
+import org.apache.fineract.portfolio.savings.service.FdBaseInterestRateWritePlatformService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class CreateCbsBaseInterestRateCommandHandlerTest {
+
+    @Mock
+    private FdBaseInterestRateWritePlatformService writePlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @InjectMocks
+    private CreateCbsBaseInterestRateCommandHandler underTest;
+
+    @Test
+    void shouldDelegateToWritePlatformServiceAndReturnResult() {
+        CommandProcessingResult expectedResult = new CommandProcessingResultBuilder()
+                .withCommandId(100L)
+                .withEntityId(200L)
+                .build();
+        when(writePlatformService.saveInterestRates(command)).thenReturn(expectedResult);
+
+        CommandProcessingResult actualResult = underTest.processCommand(command);
+
+        verify(writePlatformService).saveInterestRates(command);
+        assertEquals(expectedResult, actualResult);
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/savings/handler/CreateSavingsProductCommandHandlerTest.java

@@ -0,0 +1,60 @@
+/**
+ * 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.savings.handler;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder;
+import org.apache.fineract.portfolio.savings.service.SavingsProductWritePlatformService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class CreateSavingsProductCommandHandlerTest {
+
+    @Mock
+    private SavingsProductWritePlatformService writePlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @InjectMocks
+    private CreateSavingsProductCommandHandler underTest;
+
+    @Test
+    void shouldDelegateToWritePlatformServiceAndReturnResult() {
+        CommandProcessingResult expectedResult = new CommandProcessingResultBuilder()
+                .withCommandId(102L)
+                .withEntityId(202L)
+                .build();
+        when(writePlatformService.create(command)).thenReturn(expectedResult);
+
+        CommandProcessingResult actualResult = underTest.processCommand(command);
+
+        verify(writePlatformService).create(command);
+        assertEquals(expectedResult, actualResult);
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/savings/handler/current/CreateCurrentProductCommandHandlerTest.java

@@ -0,0 +1,60 @@
+/**
+ * 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.savings.handler.current;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder;
+import org.apache.fineract.portfolio.currentproduct.service.CurrentProductWritePlatformService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class CreateCurrentProductCommandHandlerTest {
+
+    @Mock
+    private CurrentProductWritePlatformService writePlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @InjectMocks
+    private CreateCurrentProductCommandHandler underTest;
+
+    @Test
+    void shouldDelegateToWritePlatformServiceAndReturnResult() {
+        CommandProcessingResult expectedResult = new CommandProcessingResultBuilder()
+                .withCommandId(103L)
+                .withEntityId(203L)
+                .build();
+        when(writePlatformService.create(command)).thenReturn(expectedResult);
+
+        CommandProcessingResult actualResult = underTest.processCommand(command);
+
+        verify(writePlatformService).create(command);
+        assertEquals(expectedResult, actualResult);
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/savings/service/FdBaseInterestRateReadPlatformServiceImplTest.java

@@ -0,0 +1,265 @@
+/**
+ * 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.savings.service;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.math.BigDecimal;
+import java.util.Collections;
+import java.util.List;
+import org.apache.fineract.infrastructure.core.domain.FineractPlatformTenant;
+import org.apache.fineract.infrastructure.core.exception.PlatformApiDataValidationException;
+import org.apache.fineract.infrastructure.core.service.ThreadLocalContextUtil;
+import org.apache.fineract.portfolio.savings.api.FdInterestRateSaveRequest;
+import org.apache.fineract.portfolio.savings.domain.FdBaseInterestRateEffective;
+import org.apache.fineract.portfolio.savings.domain.FdBaseInterestRateEffectiveRepository;
+import org.apache.fineract.portfolio.savings.domain.FdBaseInterestRateSlabHistoryRepository;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class FdBaseInterestRateReadPlatformServiceImplTest {
+
+    @Mock
+    private FdBaseInterestRateEffectiveRepository effectiveRepository;
+
+    @Mock
+    private FdBaseInterestRateSlabHistoryRepository slabRepository;
+
+    @InjectMocks
+    private FdBaseInterestRateReadPlatformServiceImpl service;
+
+    @BeforeEach
+    void setUp() {
+        ThreadLocalContextUtil.setTenant(new FineractPlatformTenant(1L, "default", "Default", "Asia/Kolkata", null));
+    }
+
+    @AfterEach
+    void tearDown() {
+        ThreadLocalContextUtil.setTenant(null);
+    }
+
+    private FdInterestRateSaveRequest.SlabRequest createSlab(int srNo, String desc, int periodType, int from, Integer to, double rate, double seniorRate) {
+        FdInterestRateSaveRequest.SlabRequest s = new FdInterestRateSaveRequest.SlabRequest();
+        s.setSrNo(srNo);
+        s.setDescription(desc);
+        s.setPeriodTypeEnum(periodType);
+        s.setFromPeriod(from);
+        s.setToPeriod(to);
+        s.setAnnualInterestRate(BigDecimal.valueOf(rate));
+        s.setSeniorCitizenRate(BigDecimal.valueOf(seniorRate));
+        return s;
+    }
+
+    @Test
+    void testValidSingleDepositSlabs() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        request.setVersionLabel("v1.0");
+
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, 4.5, 5.0),
+                createSlab(2, "30 to 89 Days", 0, 30, 89, 5.0, 5.5),
+                createSlab(3, "90 to 179 Days", 0, 90, 179, 5.5, 6.0),
+                createSlab(4, "180+ Days", 0, 180, null, 6.0, 6.5)
+        );
+        request.setSlabs(slabs);
+
+        when(effectiveRepository.findByFdTypeAndIsActiveTrueOrderByEffectiveFromDateDesc("SINGLE"))
+                .thenReturn(Collections.emptyList());
+        when(effectiveRepository.saveAndFlush(any())).thenAnswer(invocation -> invocation.getArgument(0));
+
+        assertDoesNotThrow(() -> service.saveInterestRates(request, 1L));
+        verify(effectiveRepository).saveAndFlush(any());
+    }
+
+    @Test
+    void testValidDoubleDepositSlabs() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("DOUBLE");
+        request.setVersionLabel("v1.0");
+
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 2 Years", 3, 1, 2, 6.5, 7.0),
+                createSlab(2, "3 to 5 Years", 3, 3, 5, 6.75, 7.25),
+                createSlab(3, "6 to 10 Years", 3, 6, 10, 7.0, 7.5),
+                createSlab(4, "11+ Years", 3, 11, null, 7.25, 7.75)
+        );
+        request.setSlabs(slabs);
+
+        when(effectiveRepository.findByFdTypeAndIsActiveTrueOrderByEffectiveFromDateDesc("DOUBLE"))
+                .thenReturn(Collections.emptyList());
+        when(effectiveRepository.saveAndFlush(any())).thenAnswer(invocation -> invocation.getArgument(0));
+
+        assertDoesNotThrow(() -> service.saveInterestRates(request, 1L));
+    }
+
+    @Test
+    void testInvalidFirstSlabDoesNotStartAtOne() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "2 to 29 Days", 0, 2, 29, 4.5, 5.0),
+                createSlab(2, "30+ Days", 0, 30, null, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals(1, ex.getErrors().size());
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[1].fromPeriod.first.slab.must.start.at.one",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidOverlapRanges() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, 4.5, 5.0),
+                createSlab(2, "20 to 50 Days", 0, 20, 50, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[2].fromPeriod.must.not.overlap.previous.range",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidGapBetweenRanges() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, 4.5, 5.0),
+                createSlab(2, "35 to 89 Days", 0, 35, 89, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[2].fromPeriod.must.be.continuous.with.previous.range",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidDuplicateRanges() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, 4.5, 5.0),
+                createSlab(2, "1 to 29 Days duplicate", 0, 1, 29, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[2].fromPeriod.must.not.overlap.previous.range",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidFromGreaterThanTo() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 20 Days", 0, 1, 20, 4.5, 5.0),
+                createSlab(2, "21 to 10 Days", 0, 21, 10, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[2].toPeriod.cannot.be.less.than.fromPeriod",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidBlankToPeriodOnIntermediateSlab() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to null Days", 0, 1, null, 4.5, 5.0),
+                createSlab(2, "30+ Days", 0, 30, null, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[1].toPeriod.cannot.be.blank.for.intermediate.slab",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidMixedPeriodTypes() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, 4.5, 5.0),
+                createSlab(2, "30 to 89 Months", 2, 30, 89, 5.0, 5.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[2].periodTypeEnum.must.be.consistent.across.all.slabs",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidNegativeInterestRate() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, -1.0, 5.0)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[1].annualInterestRate.must.be.non.negative",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+
+    @Test
+    void testInvalidNegativeSeniorRate() {
+        FdInterestRateSaveRequest request = new FdInterestRateSaveRequest();
+        request.setFdType("SINGLE");
+        List<FdInterestRateSaveRequest.SlabRequest> slabs = List.of(
+                createSlab(1, "1 to 29 Days", 0, 1, 29, 4.5, -0.5)
+        );
+        request.setSlabs(slabs);
+
+        PlatformApiDataValidationException ex = assertThrows(PlatformApiDataValidationException.class,
+                () -> service.saveInterestRates(request, 1L));
+        assertEquals("validation.msg.FD_BASE_INTEREST_RATE_VERSION.slabs[1].seniorCitizenRate.must.be.non.negative",
+                ex.getErrors().get(0).getUserMessageGlobalisationCode());
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/savings/service/FdBaseInterestRateWritePlatformServiceImplTest.java

@@ -0,0 +1,80 @@
+/**
+ * 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.savings.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.security.service.PlatformSecurityContext;
+import org.apache.fineract.portfolio.savings.api.FdInterestRateSaveRequest;
+import org.apache.fineract.portfolio.savings.data.FdInterestRateEffectiveData;
+import org.apache.fineract.useradministration.domain.AppUser;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class FdBaseInterestRateWritePlatformServiceImplTest {
+
+    @Mock
+    private PlatformSecurityContext context;
+
+    @Mock
+    private FdBaseInterestRateReadPlatformService readPlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @Mock
+    private AppUser appUser;
+
+    @InjectMocks
+    private FdBaseInterestRateWritePlatformServiceImpl writePlatformService;
+
+    @Test
+    void shouldParseJsonAndSaveInterestRates() {
+        String jsonPayload = "{\"fdType\":\"SINGLE\",\"versionLabel\":\"v1.0\",\"slabs\":[{\"srNo\":1,\"description\":\"1 to 29 Days\",\"periodTypeEnum\":0,\"fromPeriod\":1,\"toPeriod\":29,\"annualInterestRate\":5.0,\"seniorCitizenRate\":5.5}]}";
+        when(command.json()).thenReturn(jsonPayload);
+        when(command.commandId()).thenReturn(789L);
+        when(context.authenticatedUser()).thenReturn(appUser);
+        when(appUser.getId()).thenReturn(1L);
+
+        FdInterestRateEffectiveData savedData = FdInterestRateEffectiveData.builder()
+                .id(10L)
+                .fdType("SINGLE")
+                .versionLabel("v1.0")
+                .build();
+        when(readPlatformService.saveInterestRates(any(FdInterestRateSaveRequest.class), eq(1L))).thenReturn(savedData);
+
+        CommandProcessingResult result = writePlatformService.saveInterestRates(command);
+
+        assertNotNull(result);
+        assertEquals(789L, result.getCommandId());
+        assertEquals(10L, result.getResourceId());
+        verify(readPlatformService).saveInterestRates(any(FdInterestRateSaveRequest.class), eq(1L));
+    }
+}

fineract-provider/src/test/java/org/apache/fineract/portfolio/shareproducts/handler/CreateShareProductCommandHandlerTest.java

@@ -0,0 +1,60 @@
+/**
+ * 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.shareproducts.handler;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.apache.fineract.infrastructure.core.api.JsonCommand;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResult;
+import org.apache.fineract.infrastructure.core.data.CommandProcessingResultBuilder;
+import org.apache.fineract.portfolio.shareproducts.service.ShareProductWritePlatformService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class CreateShareProductCommandHandlerTest {
+
+    @Mock
+    private ShareProductWritePlatformService writePlatformService;
+
+    @Mock
+    private JsonCommand command;
+
+    @InjectMocks
+    private CreateShareProductCommandHandler underTest;
+
+    @Test
+    void shouldDelegateToWritePlatformServiceAndReturnResult() {
+        CommandProcessingResult expectedResult = new CommandProcessingResultBuilder()
+                .withCommandId(104L)
+                .withEntityId(204L)
+                .build();
+        when(writePlatformService.createShareProduct(command)).thenReturn(expectedResult);
+
+        CommandProcessingResult actualResult = underTest.processCommand(command);
+
+        verify(writePlatformService).createShareProduct(command);
+        assertEquals(expectedResult, actualResult);
+    }
+}