diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java new file mode 100644 index 0000000..ef3735f --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java @@ -0,0 +1,300 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.DesiredSubscriptionDuration; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.time.LocalDate; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class SubscriptionRepositoryTest { + + private SubscriptionRepository repository; + private PaymentMethod paymentMethod; + private Subscription subscription1; + private Subscription subscription2; + private Subscription subscription3; + + @BeforeEach + void setUp() { + repository = new SubscriptionRepository(); + + paymentMethod = PaymentMethod.builder() + .paymentType(PaymentType.CB.name()) + .details("Maxime Lebreton") + .build(); + + LocalDate desiredStartDate1 = LocalDate.of(2026, 6, 24); + subscription1 = Subscription.builder() + .customerId(UUID.randomUUID()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate1) + .monthlyAmount(12.03) + .build(); + subscription1.setRandomSubscriptionUUID(); + subscription1.setDateSubscription(); + + UUID customCustomerId = UUID.randomUUID(); + + LocalDate desiredStartDate2 = LocalDate.of(2026, 7, 24); + subscription2 = Subscription.builder() + .customerId(customCustomerId) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.SIX.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate2) + .monthlyAmount(20) + .build(); + subscription2.setRandomSubscriptionUUID(); + subscription2.setDateSubscription(); + + LocalDate desiredStartDate3 = LocalDate.of(2026, 8, 24); + subscription3 = Subscription.builder() + .customerId(customCustomerId) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.TWELVE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate3) + .monthlyAmount(30) + .build(); + subscription3.setRandomSubscriptionUUID(); + subscription3.setDateSubscription(); + } + + @Test + @DisplayName("New subecription should be empty") + void testNewRepositoryIsEmpty() { + List subscriptions = repository.findAll(); + + assertTrue(subscriptions.isEmpty()); + assertEquals(0, subscriptions.size()); + } + + @Nested + @DisplayName("Save operations") + class SaveOperations { + + @Test + @DisplayName("Save should add a new customer") + void testSaveNewSubscription() { + Subscription savedSubscription = repository.save(subscription1); + + assertEquals(1, repository.findAll().size()); + assertEquals(subscription1.getSubscriptionId(), savedSubscription.getSubscriptionId()); + assertEquals(subscription1.getMonthlyAmount(), savedSubscription.getMonthlyAmount()); + } + + @Test + @DisplayName("Save should update existing subscription with same ID") + void testSaveUpdatesExistingSubscription() { + repository.save(subscription1); + + UUID subscriptionId = subscription1.getSubscriptionId(); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + Subscription updatedSubscription = Subscription.builder() + .subscriptionId(subscriptionId) + .customerId(UUID.randomUUID()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.SIX.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .monthlyAmount(20) + .build(); + + Subscription savedCustomer = repository.save(updatedSubscription); + + assertEquals(1, repository.findAll().size()); + assertEquals(subscriptionId, savedCustomer.getSubscriptionId()); + assertEquals(6, savedCustomer.getDesiredSubscriptionDuration()); + assertEquals(20, savedCustomer.getMonthlyAmount()); + } + + @Test + @DisplayName("Save multiple subscriptions should add all of them") + void testSaveMultipleSubscriptions() { + repository.save(subscription1); + repository.save(subscription2); + + List subscriptions = repository.findAll(); + + assertEquals(2, subscriptions.size()); + assertTrue(subscriptions.contains(subscription1)); + assertTrue(subscriptions.contains(subscription2)); + } + } + + @Nested + @DisplayName("Find operations") + class FindOperations { + + @BeforeEach + void setUpSubscriptions() { + repository.save(subscription1); + repository.save(subscription2); + repository.save(subscription3); + } + + @Test + @DisplayName("FindAll should return all subscriptions") + void testFindAll() { + List subscriptions = repository.findAll(); + + assertEquals(2, subscriptions.size()); + assertTrue(subscriptions.contains(subscription1)); + assertTrue(subscriptions.contains(subscription2)); + } + + @Test + @DisplayName("FindBySubscriptionId should return subscription with matching ID") + void testFindBySubscriptionId() { + Optional foundSubscription = repository.FindBySubscriptionId(subscription1.getSubscriptionId()); + + assertTrue(foundSubscription.isPresent()); + assertEquals(subscription1.getStartDate(), foundSubscription.get().getStartDate()); + assertEquals(subscription1.getMonthlyAmount(), foundSubscription.get().getMonthlyAmount()); + } + + @Test + @DisplayName("FindBySubscriptionId should return empty Optional when ID doesn't exist") + void testFindBySubscriptionIdNotFound() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + + Optional foundSubscription = repository.FindBySubscriptionId(nonExistentSubscriptionId); + + assertTrue(foundSubscription.isEmpty()); + } + + @Test + @DisplayName("FindByCustomerId should return subscription with matching ID") + void testFindByCustomerId() { + List foundSubscriptions = repository.FindByCustomerId(subscription2.getCustomerId()); + + assertFalse(foundSubscriptions.isEmpty()); + assertTrue(foundSubscriptions.contains(subscription2)); + assertTrue(foundSubscriptions.contains(subscription3)); + } + + @Test + @DisplayName("FindByCustomerId should return empty Optional when ID doesn't exist") + void testFindByCustomerIdNotFound() { + UUID nonExistentCustomerId = UUID.randomUUID(); + + List foundSubscription = repository.FindByCustomerId(nonExistentCustomerId); + + assertTrue(foundSubscription.isEmpty()); + } + + @Test + @DisplayName("ExistsBySubscriptionId should return true when ID exists") + void testExistsBySubscriptionIdExists() { + boolean exists = repository.existsBySubscriptionId(subscription1.getSubscriptionId()); + + assertTrue(exists); + } + + @Test + @DisplayName("ExistsBySubscriptionId should return false when ID doesn't exist") + void testExistsBySubscriptionIdNotExists() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + + boolean exists = repository.existsBySubscriptionId(nonExistentSubscriptionId); + + assertFalse(exists); + } + + @Test + @DisplayName("ExistsByCustomerId should return true when ID exists") + void testExistsByCustomerIdExists() { + boolean exists = repository.existsByCustomerId(subscription1.getCustomerId()); + + assertTrue(exists); + } + + @Test + @DisplayName("ExistsByCustomerId should return false when ID doesn't exist") + void testExistsByCustomerIdNotExists() { + UUID nonExistentCustomerId = UUID.randomUUID(); + + boolean exists = repository.existsByCustomerId(nonExistentCustomerId); + + assertFalse(exists); + } + } + + @Nested + @DisplayName("Delete operations") + class DeleteOperations { + + @BeforeEach + void setUpSubscriptions() { + repository.save(subscription1); + repository.save(subscription2); + repository.save(subscription3); + } + + @Test + @DisplayName("Delete should remove the specified subscription") + void testDelete() { + repository.delete(subscription1); + + List subscriptions = repository.findAll(); + + assertEquals(2, subscriptions.size()); + assertFalse(subscriptions.contains(subscription1)); + assertTrue(subscriptions.contains(subscription2)); + assertTrue(subscriptions.contains(subscription3)); + } + + @Test + @DisplayName("DeleteAll should remove all subscriptions of a customer") + void testDeleteAll() { + repository.deleteByCustomerId(subscription2.getCustomerId()); + + List subscriptions = repository.findAll(); + + assertEquals(1, subscriptions.size()); + assertTrue(subscriptions.contains(subscription1)); + } + + @Test + @DisplayName("DeleteAll should remove all subscriptions") + void testDeleteAll() { + repository.deleteAll(); + + List subscriptions = repository.findAll(); + + assertTrue(subscriptions.isEmpty()); + assertEquals(0, subscriptions.size()); + } + + @Test + @DisplayName("Delete should not throw exception when customer doesn't exist") + void testDeleteNonExistentCustomer() { + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + Subscription nonExistentsubscription = Subscription.builder() + .customerId(UUID.randomUUID()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .monthlyAmount(12.03) + .build(); + nonExistentsubscription.setRandomSubscriptionUUID(); + nonExistentsubscription.setDateSubscription(); + + assertDoesNotThrow(() -> repository.delete(nonExistentsubscription)); + + assertEquals(3, repository.findAll().size()); + } + } +}