backend tests: Add several test classes

For:
- CoinChangeService
- ListUtil
- DenominationValidator
- CoinChangeRequest

spring_backend/src/test/java/com/keiyam/spring_backend/dto/CoinChangeRequestValidationTest.java

@@ -0,0 +1,151 @@
+package com.keiyam.spring_backend.dto;
+
+import jakarta.validation.ConstraintViolation;
+import jakarta.validation.Validation;
+import jakarta.validation.Validator;
+import jakarta.validation.ValidatorFactory;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CoinChangeRequestValidationTest {
+
+    private Validator validator;
+
+    @BeforeEach
+    void setUp() {
+        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
+        this.validator = factory.getValidator();
+    }
+
+    @Test
+    void testValidCoinChangeRequest() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10.00"));
+        request.setDenominations(Arrays.asList(
+                BigDecimal.valueOf(0.01),
+                BigDecimal.valueOf(0.05),
+                BigDecimal.valueOf(0.1),
+                BigDecimal.valueOf(0.2),
+                BigDecimal.valueOf(1),
+                BigDecimal.valueOf(5),
+                BigDecimal.valueOf(10)
+        ));
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertTrue(violations.isEmpty());
+    }
+
+    @Test
+    void testNullAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(null);
+        request.setDenominations(Arrays.asList(
+                BigDecimal.valueOf(0.01),
+                BigDecimal.valueOf(0.05),
+                BigDecimal.valueOf(0.1),
+                BigDecimal.valueOf(0.2),
+                BigDecimal.valueOf(1),
+                BigDecimal.valueOf(5),
+                BigDecimal.valueOf(10)
+        ));
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertEquals(1, violations.size());
+        assertEquals("Amount cannot be null", violations.iterator().next().getMessage());
+    }
+
+    @Test
+    void testNegativeAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("-1.00"));
+        request.setDenominations(Arrays.asList(
+                BigDecimal.valueOf(0.01),
+                BigDecimal.valueOf(0.05),
+                BigDecimal.valueOf(0.1),
+                BigDecimal.valueOf(0.2),
+                BigDecimal.valueOf(1),
+                BigDecimal.valueOf(5),
+                BigDecimal.valueOf(10)
+        ));
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertEquals(1, violations.size());
+        assertEquals("Amount must be greater than or equal to 0", violations.iterator().next().getMessage());
+    }
+
+    @Test
+    void testAmountExceedsMax() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10000.01"));
+        request.setDenominations(Arrays.asList(
+                BigDecimal.valueOf(0.01),
+                BigDecimal.valueOf(0.05),
+                BigDecimal.valueOf(0.1),
+                BigDecimal.valueOf(0.2),
+                BigDecimal.valueOf(1),
+                BigDecimal.valueOf(5),
+                BigDecimal.valueOf(10)
+        ));
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertEquals(1, violations.size());
+        assertEquals("Amount must be less than or equal to 10000.00", violations.iterator().next().getMessage());
+    }
+
+    @Test
+    void testNullDenominations() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10.00"));
+        request.setDenominations(null);
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertEquals(1, violations.size());
+        assertEquals("Denominations cannot be null", violations.iterator().next().getMessage());
+    }
+
+    @Test
+    void testInvalidDenominations() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10.00"));
+        request.setDenominations(Arrays.asList(
+                BigDecimal.valueOf(0.03),
+                BigDecimal.valueOf(0.07),
+                BigDecimal.valueOf(0.11),
+                BigDecimal.valueOf(0.21)
+        ));
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertEquals(1, violations.size());
+        assertEquals("Invalid coin denominations", violations.iterator().next().getMessage());
+    }
+
+    @Test
+    void testMixedValidAndInvalidDenominations() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10.00"));
+        request.setDenominations(Arrays.asList(
+                BigDecimal.valueOf(0.01),
+                BigDecimal.valueOf(0.03),
+                BigDecimal.valueOf(0.05),
+                BigDecimal.valueOf(0.07)
+        ));
+
+        Set<ConstraintViolation<CoinChangeRequest>> violations = validator.validate(request);
+
+        assertEquals(1, violations.size());
+        assertEquals("Invalid coin denominations", violations.iterator().next().getMessage());
+    }
+}

spring_backend/src/test/java/com/keiyam/spring_backend/service/CoinChangeServiceEdgeCaseTest.java

@@ -0,0 +1,81 @@
+package com.keiyam.spring_backend.service;
+
+import com.keiyam.spring_backend.dto.CoinChangeRequest;
+import com.keiyam.spring_backend.interfaces.ICoinChangeService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CoinChangeServiceEdgeCaseTest {
+
+    private ICoinChangeService coinChangeService;
+
+    @BeforeEach
+    void setUp() {
+        coinChangeService = new CoinChangeService();
+    }
+
+    @Test
+    void testCalculateMinCoinChange_ExactMatch() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10.00"));
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.01"),
+                new BigDecimal("0.05"),
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1"),
+                new BigDecimal("5"),
+                new BigDecimal("10")
+        ));
+
+        List<Double> result = coinChangeService.calculateMinCoinChange(request);
+
+        assertEquals(Arrays.asList(10.0), result);
+    }
+
+    @Test
+    void testCalculateMinCoinChange_MinAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(BigDecimal.ZERO);
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.01"),
+                new BigDecimal("0.05"),
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1")
+        ));
+
+        List<Double> result = coinChangeService.calculateMinCoinChange(request);
+
+        assertTrue(result.isEmpty());
+    }
+
+    @Test
+    void testCalculateMinCoinChange_MaxAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10000.00"));
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.01"),
+                new BigDecimal("0.05"),
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1"),
+                new BigDecimal("5"),
+                new BigDecimal("10"),
+                new BigDecimal("50"),
+                new BigDecimal("100"),
+                new BigDecimal("1000")
+        ));
+
+        List<Double> result = coinChangeService.calculateMinCoinChange(request);
+        assertEquals(Arrays.asList(1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0), result);
+
+        assertFalse(result.isEmpty());
+    }
+}

spring_backend/src/test/java/com/keiyam/spring_backend/service/CoinChangeServiceInvalidInputTest.java

@@ -0,0 +1,57 @@
+package com.keiyam.spring_backend.service;
+
+import com.keiyam.spring_backend.dto.CoinChangeRequest;
+import com.keiyam.spring_backend.exception.InvalidCoinChangeRequestException;
+import com.keiyam.spring_backend.interfaces.ICoinChangeService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class CoinChangeServiceInvalidInputTest {
+
+    private ICoinChangeService coinChangeService;
+
+    @BeforeEach
+    void setUp() {
+        coinChangeService = new CoinChangeService();
+    }
+
+    @Test
+    void testCalculateMinCoinChange_CannotMakeExactAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("3.33"));
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1"),
+                new BigDecimal("2")
+        ));
+
+        InvalidCoinChangeRequestException exception = assertThrows(
+                InvalidCoinChangeRequestException.class,
+                () -> coinChangeService.calculateMinCoinChange(request)
+        );
+
+        assertEquals("Cannot make the exact amount with the given denominations.", exception.getMessage());
+    }
+
+    @Test
+    void testCalculateMinCoinChange_EmptyDenominations() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("10.00"));
+        request.setDenominations(Arrays.asList());
+
+        InvalidCoinChangeRequestException exception = assertThrows(
+                InvalidCoinChangeRequestException.class,
+                () -> coinChangeService.calculateMinCoinChange(request)
+        );
+
+        assertEquals("Cannot make the exact amount with the given denominations.", exception.getMessage());
+    }
+
+}

spring_backend/src/test/java/com/keiyam/spring_backend/service/CoinChangeServiceTest.java

@@ -0,0 +1,81 @@
+package com.keiyam.spring_backend.service;
+
+import com.keiyam.spring_backend.dto.CoinChangeRequest;
+import com.keiyam.spring_backend.interfaces.ICoinChangeService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CoinChangeServiceTest {
+
+    private ICoinChangeService coinChangeService;
+
+    @BeforeEach
+    void setUp() {
+        coinChangeService = new CoinChangeService();
+    }
+
+    @Test
+    void testCalculateMinCoinChange_ValidInput() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("11.25"));
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.01"),
+                new BigDecimal("0.05"),
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1"),
+                new BigDecimal("5")
+        ));
+
+        List<Double> result = coinChangeService.calculateMinCoinChange(request);
+
+        assertEquals(Arrays.asList(0.25, 1.0, 5.0, 5.0), result);
+    }
+
+    @Test
+    void testCalculateMinCoinChange_SmallAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("0.02"));
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.01"),
+                new BigDecimal("0.05"),
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1")
+        ));
+
+        List<Double> result = coinChangeService.calculateMinCoinChange(request);
+
+        assertEquals(Arrays.asList(0.01, 0.01), result);
+    }
+
+    @Test
+    void testCalculateMinCoinChange_LargeAmount() {
+        CoinChangeRequest request = new CoinChangeRequest();
+        request.setAmount(new BigDecimal("9876.54"));
+        request.setDenominations(Arrays.asList(
+                new BigDecimal("0.01"),
+                new BigDecimal("0.05"),
+                new BigDecimal("0.1"),
+                new BigDecimal("0.25"),
+                new BigDecimal("1"),
+                new BigDecimal("5"),
+                new BigDecimal("10"),
+                new BigDecimal("50"),
+                new BigDecimal("100"),
+                new BigDecimal("1000")
+        ));
+
+        List<Double> result = coinChangeService.calculateMinCoinChange(request);
+        assertEquals(Arrays.asList(0.01, 0.01, 0.01, 0.01, 0.25, 0.25, 1.0, 5.0, 10.0, 10.0, 50.0, 100.0, 100.0,
+                100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0, 1000.0), result);
+
+        assertFalse(result.isEmpty());
+    }
+}