From 9d49b597e94e8945140c9dbdee9baf5abfddc197 Mon Sep 17 00:00:00 2001 From: Axel Pietrois Date: Sat, 7 Jun 2025 14:52:44 +0200 Subject: [PATCH 1/2] =?UTF-8?q?J'avais=20oubli=C3=A9=20des=20customer=20da?= =?UTF-8?q?ns=20book?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/.gitignore | 8 + .idea/vcs.xml | 4 + .../book/usecase/BookUseCaseTest.java | 11 +- .../subscription/SubscriptionSteps.java | 116 +++++++++++++ .../converter/SubscriptionConverterTest.java | 105 ++++++++++++ .../subscription/entity/SubscriptionTest.java | 49 ++++++ .../SubscriptionRepositoryTest.java | 157 ++++++++++++++++++ .../usecase/SubscribeUseCaseTest.java | 111 +++++++++++++ .../validator/SubscriptionValidatorTest.java | 121 ++++++++++++++ .../resources/features/subscription.feature | 28 ++++ 10 files changed, 704 insertions(+), 6 deletions(-) create mode 100644 .idea/.gitignore create mode 100644 .idea/vcs.xml create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java create mode 100644 src/test/resources/features/subscription.feature diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..d843f34 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCaseTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCaseTest.java index 3124c88..25b584a 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCaseTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/book/usecase/BookUseCaseTest.java @@ -1,6 +1,5 @@ package fr.iut_fbleau.but3.dev62.mylibrary.book.usecase; -import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -21,7 +20,7 @@ import static org.mockito.Mockito.*; public class BookUseCaseTest { @Mock - private BookRepository customerRepository; + private BookRepository bookRepository; @InjectMocks private BookUseCase bookUseCase; @@ -47,7 +46,7 @@ public class BookUseCaseTest { .language("Francais") .build(); - validBookInfo = new CustomerInfo("LivreRandom", "John Doe", "RandomPublisher", date, 12.5, 50, cat, "Je suis un livre qui est composé de mots.", "Francais"); + validBookInfo = new BookInfo("LivreRandom", "John Doe", "RandomPublisher", date, 12.5, 50, cat, "Je suis un livre qui est composé de mots.", "Francais"); } @@ -57,7 +56,7 @@ public class BookUseCaseTest { public class RegisterBookTests { @Test - @DisplayName("Should register customer when valid data is provided") + @DisplayName("Should register book when valid data is provided") void testRegisterBookWithValidData() throws NotValidBookException { when(BookRepository.save(any(Book.class))).thenReturn(testBook); @@ -69,7 +68,7 @@ public class BookUseCaseTest { } @Test - @DisplayName("Should throw exception when customer data is not valid") + @DisplayName("Should throw exception when book data is not valid") void testRegisterBookWithInvalidData() { BookInfo invalidBookInfo = new BookInfo("", "", ""); @@ -86,7 +85,7 @@ public class BookUseCaseTest { @Nested - @DisplayName("Find customer tests") + @DisplayName("Find book tests") class FindBookTests { @Test diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java new file mode 100644 index 0000000..7fc7c0b --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java @@ -0,0 +1,116 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.features.subscription; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository; +import io.cucumber.datatable.DataTable; +import io.cucumber.java.en.And; +import io.cucumber.java.en.Given; +import io.cucumber.java.en.Then; +import io.cucumber.java.en.When; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; + + +public class SubscriptionSteps { + + private final CustomerRepository customerRepository = new CustomerRepository(); + + private final Map customerPhoneUUID = new HashMap<>(); + + @Given("the system has the following customers:") + public void theSystemHasTheFollowingCustomers(DataTable dataTable) { + int size = customerRepository.findAll().size(); + + if (size > 0) { + customerRepository.deleteAll(); + } + + List> customers = dataTable.asMaps(String.class, String.class); + + for (Map customer : customers) { + String numeroTelephone = customer.get("numeroTelephone"); + Customer newCustomer = Customer.builder() + .firstName(customer.get("prenom")) + .lastName(customer.get("nom")) + .phoneNumber(numeroTelephone) + .loyaltyPoints(Integer.parseInt(customer.get("pointsFidelite"))) + .build(); + Customer save = customerRepository.save(newCustomer); + customerPhoneUUID.put(numeroTelephone, save.getId()); + } + + assertEquals(customers.size(), customerRepository.findAll().size()); + } + + @When("I create a new subscription with CB:") + public void iCreateANewSubscriptionWithCB(DataTable dataTable) { + List> rows = dataTable.asMaps(String.class, String.class); + + Map customerInfo = rows.getFirst(); + + SubscriptionInfo newSubscription = new subscriptionInfo( + subscriptionInfo.get("customerId"), + subscriptionInfo.get("duration"), + subscriptionInfo.get("paymentMethod"), + subscriptionInfo.get("debutDate") + ); + + subscriptionRegistration = subscriptionUseCase.registerSubscription(newSubscription); + } + + @Then("a new subscription is created") + public void aNewSubscriptionIsCreated() { + + } + + @When("I create a new subscription with Paypal:") + public void iCreateANewSubscriptionWithPaypal(DataTable dataTable) { + List> rows = dataTable.asMaps(String.class, String.class); + + Map customerInfo = rows.getFirst(); + + SubscriptionInfo newSubscription = new subscriptionInfo( + subscriptionInfo.get("customerId"), + subscriptionInfo.get("duration"), + subscriptionInfo.get("paymentMethod"), + subscriptionInfo.get("debutDate") + ); + + subscriptionRegistration = subscriptionUseCase.registerSubscription(newSubscription); + } + + @When("I try to create a new subscription with the following information:") + public void iTryToCreateANewSubscriptionWithTheFollowingInformation(DataTable dataTable) { + List> rows = dataTable.asMaps(String.class, String.class); + + Map customerInfo = rows.getFirst(); + + SubscriptionInfo newSubscription = new subscriptionInfo( + subscriptionInfo.get("customerId"), + subscriptionInfo.get("duration"), + subscriptionInfo.get("paymentMethod"), + subscriptionInfo.get("debutDate") + ); + + notValidSubscriptionDurationException = assertThrows(NotValidSubscriptionDurationException.class, () -> subscriptionUseCase.registerSubscription(newSubscription)); + } + + @Then("the subsription duration creation fails") + public void theSubsriptionDurationCreationFails() assertNotNull(notValidSubscriptionDurationException);{ + } + + @And("I receive an error for validation subscription message containing {string}") + public void iReceiveAnErrorForValidationSubscriptionMessageContaining(String errorMessage) { + assertEquals(errorMessage, notValidSubscriptionDurationException.getMessage()); + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java new file mode 100644 index 0000000..12b6328 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java @@ -0,0 +1,105 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.converter.CustomerConverter; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Subscription; +import java.util.UUID; +import java.util.concurrent.Flow; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +@DisplayName(SubscriptionConverter Unit Tests) +public class SubscriptionConverterTest { + + @Nested + @DisplayName("toDomain() method tests") + public class toDomainTests { + + @Test + @DisplayName("Should convert SubscriptionInfo to Subscription domain object") + void shouldConvertSubscriptionInfoToDomain() { + // Given + SubscriptionInfo subscriptionInfo = new SubcriptionInfo("1", "12", "CB", "2025-06-08"); + + // When + Subscription result = SubscriptionConverter.toDomain(subscriptionInfo); + + // Then + assertNotNull(result); + assertEquals(subscriptionInfo.customerId(), result.getCustomerId()); + assertEquals(subscriptionInfo.duration(), result.getDuration()); + assertEquals(subscriptionInfo.paymentMethod(), result.getPaymentMethod()); + assertEquals(subscriptionInfo.debutDate(), result.getDebutDate()); + } + } + + @Nested + @DisplayName("toDTO() method tests") + public class toDTOTests { + + @Test + @DisplayName("Should convert Subscriber domain object to SubscriberDTO with all fields mapped correctly") + void shouldConvertSubscriptionToDTO() { + Subscription subscription = Subscription.builder() + .id(UUID.randomUUID()) + .customerId(1) + .duration(12) + .paymentMethod("CB") + .debutDate("2025-06-08") + .build(); + + SubscriptionDTO result = SubscriptionConverter.toDTO(customer); + + assertNotNull(result); + assertEquals(subscription.getId(), result.getId()); + assertEquals(subscription.getCustomerId(), result.getCustomerId()); + assertEquals(subscription.getDuration(), result.getDuration()); + assertEquals(subscription.getPaymentMethod(), result.getPaymentMethod()); + assertEquals(subscription.getDebutDate(), result.getDebutDate()); + } + + @Test + @DisplayName("Should handle null values properly when converting between objects") + void shouldHandleNullValuesGracefully() { + Subscription subscription = Subscription.builder() + .id(UUID.randomUUID()) + .customerId(1) + .duration(null) + .paymentMethod("NullTest") + .debutDate("2025-06-08") + .build(); + + SubscriptionDTO result = SubscriptionConverter.toDTO(subscription); + + assertNotNull(result); + assertNull(result.getDuration()); + assertEquals("NullTest", result.getPaymentMethod()); + } + + @Test + @DisplayName("Should preserve empty string values during conversion") + void shouldPreserveEmptyStrings() { + SubscriptionInfo subscriptionInfo = new SubscriptionInfo("", "", "", ""); + + Subscription domainResult = SubscriptionConverter.toDomain(subscriptionInfo); + SubscriptionDTO dtoResult = SubscriptionConverter.toDTO(domainResult); + + assertEquals("", dtoResult.getCustomerId()); + assertEquals("", dtoResult.getDuration()); + assertEquals("", dtoResult.getPaymentMethod()); + assertEquals("", dtoResult.getDebutDate()); + } + } +} + + diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java new file mode 100644 index 0000000..99c0098 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java @@ -0,0 +1,49 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import static org.junit.jupiter.api.Assertions.*; + +import java.util.UUID; + + +public class SubscriptionTest { + + @Test + @DisplayName("Builder should create a valid Subscription instance") + void testSubscriptionBuilder() { + UUID id = UUID.randomUUID(); + int customerId = 1; + int duration = 12; + String paymentMethod = "CB"; + String debutDate = "2025-06-08"; + + Subscription subscription = Subscription.builder() + .id(id) + .customerId(customerId) + .duration(duration) + .paymentMethod(paymentMethod) + .debutDate(debutDate) + .build(); + + assertEquals(id, subscription.getId()); + assertEquals(customerId, subscription.getCustomerId()); + assertEquals(duration, subscription.getDuration()); + assertEquals(paymentMethod, subscription.getPaymentMethod()); + assertEquals(debutDate, subscription.getDebutDate()); + } + + @Test + @DisplayName("setRandomUUID should change the ID to a new random UUID") + void testSetRandomUUID() { + Subscription subscription = Subscription.builder().build(); + UUID originalId = subscription.getId(); + + subscription.setRandomUUID(); + + assertNotNull(subscription.getId()); + assertNotEquals(originalId, subscription.getId()); + } + +} 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..a01acbe --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java @@ -0,0 +1,157 @@ +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.customer.repository.CustomerRepository; +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.util.List; +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +public class SubscriptionRepositoryTest { + + + private SubscriptionRepository repository; + private Subscription Subscription1; + private Subscription Subscription2; + + @BeforeEach + void setUp() { + repository = new SubscriptionRepository(); + + Subscription1 = Subscription.builder() + .customerId(1) + .duration(12) + .paymentMethod("CB") + .debutDate("2025-06-10") + .build(); + Subscription1.setRandomUUID(); + + Subscription2 = Subscription.builder() + .customerId(2) + .duration(24) + .paymentMethod("Paypal") + .debutDate("2025-06-11") + .build(); + Subscription2.setRandomUUID(); + } + + @Test + @DisplayName("New repository should be empty") + void testNewRepositoryIsEmpty() { + List subscriptions = repository.findAll(); + + assertTrue(subscriptions.isEmpty()); + assertEquals(0, subsciptions.size()); + } + + @Nested + @DisplayName("Save operations") + class SaveOperations { + + @Test + @DisplayName("Save should add a new subsciption") + void testSaveNewSubscription() { + Subscription savedSubscription = repository.save(subscription1); + + assertEquals(1, repository.findAll().size()); + assertEquals(subscription1.getId(), savedSubscription.getId()); + assertEquals(subscription1.getDebutDate(), savedSubscription.getDebutDate()); + } + + @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); + } + + @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("FindById should return subscriptions with matching ID") + void testFindById() { + Optional foundSubscription = repository.findById(subscription1.getId()); + + assertTrue(foundSubscription.isPresent()); + assertEquals(subscription1.getFirstName(), foundSubscription.get().getId()); + assertEquals(subscription1.getLastName(), foundSubscription.get().getCustomerId()); + } + + @Test + @DisplayName("FindById should return empty Optional when ID doesn't exist") + void testFindByIdNotFound() { + UUID nonExistentId = UUID.randomUUID(); + + Optional foundSubscription = repository.findById(nonExistentId); + + assertTrue(foundSubscription.isEmpty()); + } + + @Test + @DisplayName("FindByCustomerId should return customer with matching customer id") + void testFindByCustomerId() { + Optional foundSubscription = repository.findByCustomerId("1"); + + assertTrue(foundSubscription.isPresent()); + assertEquals(subscription1.getId(), foundSubscription.get().getId()); + assertEquals(subscription1.getDebutDate(), foundSubscription.get().getDebutDate()); + } + + @Test + @DisplayName("FindByCustomerId should return empty Optional when phone number doesn't exist") + void testFindByPhoneNumberNotFound() { + Optional foundSubscription = repository.findByCustomerId("0"); + + assertTrue(foundSubscription.isEmpty()); + } + + @Test + @DisplayName("ExistsById should return true when ID exists") + void testExistsByIdExists() { + boolean exists = repository.existsById(subscription1.getId()); + + assertTrue(exists); + } + + @Test + @DisplayName("ExistsById should return false when ID doesn't exist") + void testExistsByIdNotExists() { + UUID nonExistentId = UUID.randomUUID(); + + boolean exists = repository.existsById(nonExistentId); + + assertFalse(exists); + } + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java new file mode 100644 index 0000000..e4fb30f --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java @@ -0,0 +1,111 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase; + +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.entity.Subscription; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.SubscriptionNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.IllegalSubscriptionPointException; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.NotValidSubscriptionException; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.repository.SubscriptionRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.usecase.SubscriptionUseCase; +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 org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +public class SubscribeUseCaseTest { + + @Mock + private SubscriptionRepository subscriptionRepository; + + @InjectMocks + private SubscriptionUseCase subscriptionUseCase; + + private UUID subscriptionId; + private Subscription testSubscription; + private SubscriptionInfo validSubscriptionInfo; + + @BeforeEach + void setUp() { + subscriptionId = UUID.randomUUID(); + testSubscription = Subscription.builder() + .id(subscriptionId) + .CustomerId(1) + .duration(12) + .phaymentMethod("CB") + .debutDate("2025-06-10") + .build(); + + validSubscriptionInfo = new SubscriptionInfo("1", "12", "CB", "2025-06-08"); + } + + @Nested + @DisplayName("Register subscription tests") + class RegisterSubscriptionTests { + + @Test + @DisplayName("Should register subscription when valid data is provided") + void testRegisterSubscriptionWithValidData() throws NotValidSubscriptionException { + when(subscriptionRepository.save(any(Subscription.class))).thenReturn(testSubscription); + + UUID registeredId = subscriptionUseCase.registerSubscription(validSubscriptionInfo); + + assertNotNull(registeredId); + assertEquals(subscriptionId, registeredId); + verify(subscriptionRepository, times(1)).save(any(Subscription.class)); + } + + @Test + @DisplayName("Should throw exception when subscription data is not valid") + void testRegisterSubscriptionWithInvalidData() { + SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo("", "", ""); + + assertThrows(NotValidSubscriptionException.class, + () -> subscriptionUseCase.registerSubscription(invalidSubscriptionInfo)); + + verify(subscriptionRepository, never()).save(any(Subscription.class)); + } + } + + @Nested + @DisplayName("Find subscription tests") + class FindSubscriptionTests { + + @Test + @DisplayName("Should return subscription when phone number exists") + void testFindSubscriptionByCustomerId() { + when(subscriptionRepository.findByCustomerId(1)).thenReturn(Optional.of(testSubscription)); + + Optional foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(1); + + assertTrue(foundSubscription.isPresent()); + assertEquals(testSubscription.getId(), foundSubscription.get().getId()); + assertEquals(testSubscription.getDebutDate(), foundSubscription.get().getDebutDate()); + verify(subscriptionRepository, times(1)).findByCustomerId(1); + } + + @Test + @DisplayName("Should return empty Optional when phone number doesn't exist") + void testFindSubscriptionByPhoneNumberNotFound() { + when(subscriptionRepository.findByCustomerId(0)).thenReturn(Optional.empty()); + + Optional foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(0); + + assertTrue(foundSubscription.isEmpty()); + verify(subscriptionRepository, times(1)).findByCustomerId(0); + } + } + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java new file mode 100644 index 0000000..296d420 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java @@ -0,0 +1,121 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.SubscriptionValidator; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +public class SubscriptionValidatorTest { + + @Test + @DisplayName("Should validate subscription with valid data") + void testValidateValidSubscription() { + SubscriptionInfo validSubscription = new SubscriptionInfo("1", "12", "CB", "2025-06-08"); + + assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); + } + + @Nested + @DisplayName("customer id validation tests") + class CustomerIdValidationTests { + + @Test + @DisplayName("Should throw exception when customer id is blank") + void testValidateBlankCustomerId() { + SubscriptionInfo subscriptionWithBlankCustomerId = new SubscriptionInfo("", "12", "CB", "2025-06-08"); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(subscriptionWithBlankCustomerId) + ); + + assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_BLANK, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = {" ", " ", "\t", "\n"}) + @DisplayName("Should throw exception when customer id contains only whitespace") + void testValidateWhitespaceCustomerId(String whitespace) { + SubscriptionInfo subscriptionWithWhitespaceFirstName = new SubscriptionInfo(whitespace, "12", "CB", "2025-06-08"); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(subscriptionWithWhitespaceCustomerId) + ); + + assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_BLANK, exception.getMessage()); + } + } + + @Nested + @DisplayName("Duration validation tests") + class DurationValidationTests { + + @Test + @DisplayName("Should throw exception when duration is blank") + void testValidateBlankDuration() { + SubscriptionInfo subscriptionWithBlankDuration = new SubscriptionInfo("1", "", "CB", "2025-06-08"); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(subscriptionWithBlankDuration) + ); + + assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_BLANK, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = {" ", " ", "\t", "\n"}) + @DisplayName("Should throw exception when last name contains only whitespace") + void testValidateWhitespaceDuration(String whitespace) { + SubscriptionInfo subscriptionWithWhitespaceDuration = new SubscriptionInfo("1", whitespace, "CB", "2025-06-08"); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(subscriptionWithWhitespaceDuration) + ); + + assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_BLANK, exception.getMessage()); + } + } + + @Nested + @DisplayName("Payment method validation tests") + class PaymentMethodValidationTests { + + @Test + @DisplayName("Should throw exception when payment method is blank") + void testValidateBlankPaymentMethod() { + SubscriptionInfo subscriptionWithBlankPaymentMethod = new SubscriptionInfo("1", "12", "", "2025-06-08"); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(subscriptionWithBlankPaymentMethod) + ); + + assertEquals(SubscriptionValidator.PAYMENT_METHOD_CANNOT_BE_BLANK, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = {" ", " ", "\t", "\n"}) + @DisplayName("Should throw exception when payment method contains only whitespace") + void testValidateWhitespacePhoneNumber(String whitespace) { + SubscriptionInfo subscriptionWithWhitespacePhoneNumber = new SubscriptionInfo("1", "12", whitespace, "2025-06-08"); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(subscriptionWithWhitespacePaymentMethod) + ); + + assertEquals(SubscriptionValidator.PAYMENT_METHOD_CANNOT_BE_BLANK, exception.getMessage()); + } + } +} diff --git a/src/test/resources/features/subscription.feature b/src/test/resources/features/subscription.feature new file mode 100644 index 0000000..ddc7606 --- /dev/null +++ b/src/test/resources/features/subscription.feature @@ -0,0 +1,28 @@ +# language: en + +Feature: Manage customer subscription + Background: + Given the system has the following customers: + | customerId | firstName | lastNale | phoneNumer | loyaltyPoints | + | 1 | John | Doe | 0612345678 | 100 | + | 2 | Bob | Dupond | 0687654321 | 50 | + | 3 | Alice | Untel | 0698765432 | 0 | + + Scenario: Create a new subscription + When I create a new subscription with CB: + | customerId | duration | paymentMethod | debutDate | + | 1 | 12 | CB | 2025-06-10 | + Then a new subscription is created + + Scenario: Create a new subscription + When I create a new subscription with Paypal: + | customerId | duration | paymentMethod | debutDate | + | 2 | 24 | Paypal | 2025-06-11 | + Then a new subscription is created + + Scenario: Attempt to create a subscription with invalid duration: + When I try to create a new subscription with the following information: + | customerId | duration | paymentMethod | debutDate | + | 3 | 0 | CB | 2025-06-12 | + Then the subsription duration creation fails + And I receive an error for validation subscription message containing "Duration must be positive" \ No newline at end of file From 8f76a6fbd46b7de9abcb5ba176dc9e228fad4406 Mon Sep 17 00:00:00 2001 From: thuret Date: Mon, 9 Jun 2025 22:52:27 +0200 Subject: [PATCH 2/2] subscription passe ! --- .idea/encodings.xml | 7 ++ .idea/misc.xml | 12 ++++ .idea/vcs.xml | 4 +- .../subscription/SubscriptionDTO.java | 15 +++++ .../subscription/SubscriptionInfo.java | 7 ++ .../converter/SubscriptionConverter.java | 31 +++++++++ .../subscription/entity/Subscription.java | 24 +++++++ .../NotValidSubscriptionException.java | 8 +++ .../SubscriptionNotFoundException.java | 12 ++++ .../repository/SubscriptionRepository.java | 36 ++++++++++ .../usecase/SubscriptionUseCase.java | 45 +++++++++++++ .../validator/SubscriptionValidator.java | 38 +++++++++++ .../subscription/SubscriptionSteps.java | 67 +++++++++++-------- .../converter/SubscriptionConverterTest.java | 22 +++--- .../subscription/entity/SubscriptionTest.java | 2 +- .../SubscriptionRepositoryTest.java | 52 +++++++------- .../usecase/SubscribeUseCaseTest.java | 36 +++++----- .../validator/SubscriptionValidatorTest.java | 32 ++++----- .../resources/features/subscription.feature | 20 +++--- 19 files changed, 357 insertions(+), 113 deletions(-) create mode 100644 .idea/encodings.xml create mode 100644 .idea/misc.xml create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDTO.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionInfo.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverter.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionException.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..aa00ffa --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..5ddb3b3 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,12 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml index d843f34..35eb1dd 100644 --- a/.idea/vcs.xml +++ b/.idea/vcs.xml @@ -1,4 +1,6 @@ - + + + \ No newline at end of file diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDTO.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDTO.java new file mode 100644 index 0000000..6447380 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDTO.java @@ -0,0 +1,15 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +import lombok.Builder; +import lombok.Getter; +import java.util.UUID; + +@Builder +@Getter +public class SubscriptionDTO { + private final UUID id; + private final UUID customerId; + private final Integer duration; + private final String paymentMethod; + private final String debutDate; +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionInfo.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionInfo.java new file mode 100644 index 0000000..2bf5638 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionInfo.java @@ -0,0 +1,7 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +import java.util.UUID; + +public record SubscriptionInfo(UUID customerId, Integer duration, String paymentMethod) { + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverter.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverter.java new file mode 100644 index 0000000..9f8aaca --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverter.java @@ -0,0 +1,31 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter; + + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; + +public final class SubscriptionConverter { + private SubscriptionConverter() { + + } + + public static Subscription toDomain(SubscriptionInfo newSubscription) { + return Subscription.builder() + .customerId(newSubscription.customerId()) + .duration(newSubscription.duration()) + .paymentMethod(newSubscription.paymentMethod()) + .build(); + } + + public static SubscriptionDTO toDTO(Subscription subscription) { + return SubscriptionDTO.builder() + .id(subscription.getId()) + .customerId(subscription.getCustomerId()) + .duration(subscription.getDuration()) + .paymentMethod(subscription.getPaymentMethod()) + .debutDate(subscription.getDebutDate()) + .build(); + } + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java new file mode 100644 index 0000000..7d0efe3 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java @@ -0,0 +1,24 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; + +import java.util.UUID; +import lombok.Builder; +import lombok.Getter; +import java.time.LocalDate; + +@Builder +@Getter +public class Subscription { + private UUID id; + private UUID customerId; + private Integer duration; + private String paymentMethod; + private String debutDate; + + public void setRandomUUID() { + this.id = UUID.randomUUID(); + } + + public void setDebutDate(String debutDate) { + this.debutDate = LocalDate.now().toString(); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionException.java new file mode 100644 index 0000000..4ab97d2 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionException.java @@ -0,0 +1,8 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +public class NotValidSubscriptionException extends Exception { + + public NotValidSubscriptionException(String message) { + super(message); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java new file mode 100644 index 0000000..26f1e1b --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java @@ -0,0 +1,12 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +import java.text.MessageFormat; +import java.util.UUID; + +public class SubscriptionNotFoundException extends Exception { + + public static final String THE_SUBSCRIPTION_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The customer with id {0} does not exist"; + public SubscriptionNotFoundException(UUID uuid) { + super(MessageFormat.format(THE_SUBSCRIPTION_WITH_ID_DOES_NOT_EXIST_MESSAGE, uuid)); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java new file mode 100644 index 0000000..5d4e682 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java @@ -0,0 +1,36 @@ +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.entity.Subscription; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import lombok.NoArgsConstructor; + +public class SubscriptionRepository { + private final List subscriptions = new ArrayList<>(); + + public List findAll() { + return subscriptions; + } + + public Subscription save(Subscription newSubscription) { + Optional optionalSubscriptionWithSameId = this.findByCustomerId(newSubscription.getCustomerId()); + optionalSubscriptionWithSameId.ifPresentOrElse(subscriptions::remove, newSubscription::setRandomUUID); + this.subscriptions.add(newSubscription); + return newSubscription; + } + + public Optional findByCustomerId(UUID uuid) { + return this.subscriptions.stream() + .filter(subscription -> subscription.getCustomerId().equals(uuid)) + .findFirst(); + } + + public boolean existsById(UUID uuid) { + return this.subscriptions.stream() + .anyMatch(subscription -> subscription.getId().equals(uuid)); + } + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java new file mode 100644 index 0000000..a8c5e24 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java @@ -0,0 +1,45 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter.SubscriptionConverter; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.SubscriptionNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.SubscriptionValidator; +import java.util.Optional; +import java.util.UUID; + +public class SubscriptionUseCase { + + private final SubscriptionRepository subscriptionRepository; + + public SubscriptionUseCase(SubscriptionRepository subscriptionRepository) { + this.subscriptionRepository = subscriptionRepository; + } + + public UUID registerSubscription(SubscriptionInfo newSubscription) throws NotValidSubscriptionException { + SubscriptionValidator.validate(newSubscription); + Subscription subscriptionToRegister = SubscriptionConverter.toDomain(newSubscription); + Subscription subscriptionToRegistered = subscriptionRepository.save(subscriptionToRegister); + if (subscriptionToRegistered.getDuration() <= 0) { + throw new NotValidSubscriptionException("Duration must be positive"); + } + return subscriptionToRegistered.getId(); + } + + public Optional findSubscriptionByCustomerId(UUID customerId) { + Optional optionalSubscription = subscriptionRepository.findByCustomerId(customerId); + return optionalSubscription.map(SubscriptionConverter::toDTO); + } + + private boolean getSubscriptionIfDoesNotExistThrowSubscriptionNotFoundException(UUID uuid) + throws SubscriptionNotFoundException { + if (subscriptionRepository.existsById(uuid)) { + throw new SubscriptionNotFoundException(uuid); + } + return subscriptionRepository.existsById(uuid); + } + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java new file mode 100644 index 0000000..51112ec --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java @@ -0,0 +1,38 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; + +public class SubscriptionValidator { + + public static final String CUSTOMER_ID_CANNOT_BE_NULL = "Customer ID cannot be null"; + public static final String DURATION_CANNOT_BE_NULL = "Duration is not valid"; + public static final String PAYMENT_METHOD_CANNOT_BE_BLANK = "Payment Method cannot be blank"; + + + private SubscriptionValidator() { + + } + + public static void validate(SubscriptionInfo newSubscription) throws fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException { + validateDuration(newSubscription); + validatePaymentMethod(newSubscription); + } + + + private static void validateDuration(SubscriptionInfo newSubscription) throws fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException { + if (newSubscription.duration() == null) { + throw new fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException(DURATION_CANNOT_BE_NULL); + } + } + + private static void validatePaymentMethod(SubscriptionInfo newSubscription) throws fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException { + if (newSubscription.paymentMethod().isBlank()) { + throw new NotValidSubscriptionException(PAYMENT_METHOD_CANNOT_BE_BLANK); + } + } + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java index 7fc7c0b..eb52963 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java @@ -6,7 +6,13 @@ import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; -import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException; +import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase.SubscriptionUseCase; import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository; import io.cucumber.datatable.DataTable; @@ -23,8 +29,12 @@ import java.util.UUID; public class SubscriptionSteps { - private final CustomerRepository customerRepository = new CustomerRepository(); + private final SubscriptionRepository subscriptionRepository = new SubscriptionRepository(); + private final SubscriptionUseCase subscriptionUseCase = new SubscriptionUseCase(subscriptionRepository); + private NotValidSubscriptionException notValidSubscriptionException; + private final CustomerRepository customerRepository = new CustomerRepository(); + private UUID subscriptionRegistration; private final Map customerPhoneUUID = new HashMap<>(); @Given("the system has the following customers:") @@ -53,18 +63,20 @@ public class SubscriptionSteps { } @When("I create a new subscription with CB:") - public void iCreateANewSubscriptionWithCB(DataTable dataTable) { + public void iCreateANewSubscriptionWithCB(DataTable dataTable) throws NotValidSubscriptionException { List> rows = dataTable.asMaps(String.class, String.class); - Map customerInfo = rows.getFirst(); + // Extract the first row of data + Map subscriptionData = rows.getFirst(); - SubscriptionInfo newSubscription = new subscriptionInfo( - subscriptionInfo.get("customerId"), - subscriptionInfo.get("duration"), - subscriptionInfo.get("paymentMethod"), - subscriptionInfo.get("debutDate") + // Create a new SubscriptionInfo object with the correct keys + SubscriptionInfo newSubscription = new SubscriptionInfo( + UUID.fromString(subscriptionData.get("customerId")), + Integer.parseInt(subscriptionData.get("duration")), + subscriptionData.get("paymentMethod") ); + // Register the subscription subscriptionRegistration = subscriptionUseCase.registerSubscription(newSubscription); } @@ -74,43 +86,44 @@ public class SubscriptionSteps { } @When("I create a new subscription with Paypal:") - public void iCreateANewSubscriptionWithPaypal(DataTable dataTable) { + public void iCreateANewSubscriptionWithPaypal(DataTable dataTable) throws NotValidSubscriptionException { List> rows = dataTable.asMaps(String.class, String.class); - Map customerInfo = rows.getFirst(); + // Extract the first row of data + Map subscriptionData = rows.getFirst(); - SubscriptionInfo newSubscription = new subscriptionInfo( - subscriptionInfo.get("customerId"), - subscriptionInfo.get("duration"), - subscriptionInfo.get("paymentMethod"), - subscriptionInfo.get("debutDate") + // Create a new SubscriptionInfo object with the correct keys + SubscriptionInfo newSubscription = new SubscriptionInfo( + UUID.fromString(subscriptionData.get("customerId")), + Integer.parseInt(subscriptionData.get("duration")), + subscriptionData.get("paymentMethod") ); + // Register the subscription subscriptionRegistration = subscriptionUseCase.registerSubscription(newSubscription); } @When("I try to create a new subscription with the following information:") - public void iTryToCreateANewSubscriptionWithTheFollowingInformation(DataTable dataTable) { + public void iTryToCreateANewSubscriptionWithTheFollowingInformation(DataTable dataTable) throws NotValidSubscriptionException { List> rows = dataTable.asMaps(String.class, String.class); - Map customerInfo = rows.getFirst(); + Map subscriptionData = rows.getFirst(); - SubscriptionInfo newSubscription = new subscriptionInfo( - subscriptionInfo.get("customerId"), - subscriptionInfo.get("duration"), - subscriptionInfo.get("paymentMethod"), - subscriptionInfo.get("debutDate") + SubscriptionInfo newSubscription = new SubscriptionInfo( + UUID.fromString(subscriptionData.get("customerId")), + Integer.parseInt(subscriptionData.get("duration")), + subscriptionData.get("paymentMethod") ); - notValidSubscriptionDurationException = assertThrows(NotValidSubscriptionDurationException.class, () -> subscriptionUseCase.registerSubscription(newSubscription)); + notValidSubscriptionException = assertThrows(NotValidSubscriptionException.class, () -> subscriptionUseCase.registerSubscription(newSubscription)); } @Then("the subsription duration creation fails") - public void theSubsriptionDurationCreationFails() assertNotNull(notValidSubscriptionDurationException);{ - } + public void theSubsriptionDurationCreationFails() {assertNotNull(notValidSubscriptionException);} + @And("I receive an error for validation subscription message containing {string}") public void iReceiveAnErrorForValidationSubscriptionMessageContaining(String errorMessage) { - assertEquals(errorMessage, notValidSubscriptionDurationException.getMessage()); + assertEquals(errorMessage, notValidSubscriptionException.getMessage()); } } diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java index 12b6328..0fc7129 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java @@ -4,9 +4,9 @@ import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO; import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo; import fr.iut_fbleau.but3.dev62.mylibrary.customer.converter.CustomerConverter; import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; -import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Subscription; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; import java.util.UUID; import java.util.concurrent.Flow; @@ -18,7 +18,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; -@DisplayName(SubscriptionConverter Unit Tests) +@DisplayName("SubscriptionConverter Unit Tests") public class SubscriptionConverterTest { @Nested @@ -29,7 +29,7 @@ public class SubscriptionConverterTest { @DisplayName("Should convert SubscriptionInfo to Subscription domain object") void shouldConvertSubscriptionInfoToDomain() { // Given - SubscriptionInfo subscriptionInfo = new SubcriptionInfo("1", "12", "CB", "2025-06-08"); + SubscriptionInfo subscriptionInfo = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "CB"); // When Subscription result = SubscriptionConverter.toDomain(subscriptionInfo); @@ -39,7 +39,6 @@ public class SubscriptionConverterTest { assertEquals(subscriptionInfo.customerId(), result.getCustomerId()); assertEquals(subscriptionInfo.duration(), result.getDuration()); assertEquals(subscriptionInfo.paymentMethod(), result.getPaymentMethod()); - assertEquals(subscriptionInfo.debutDate(), result.getDebutDate()); } } @@ -50,15 +49,17 @@ public class SubscriptionConverterTest { @Test @DisplayName("Should convert Subscriber domain object to SubscriberDTO with all fields mapped correctly") void shouldConvertSubscriptionToDTO() { + UUID id = UUID.randomUUID(); + Subscription subscription = Subscription.builder() .id(UUID.randomUUID()) - .customerId(1) + .customerId(id) .duration(12) .paymentMethod("CB") .debutDate("2025-06-08") .build(); - SubscriptionDTO result = SubscriptionConverter.toDTO(customer); + SubscriptionDTO result = SubscriptionConverter.toDTO(subscription); assertNotNull(result); assertEquals(subscription.getId(), result.getId()); @@ -73,7 +74,7 @@ public class SubscriptionConverterTest { void shouldHandleNullValuesGracefully() { Subscription subscription = Subscription.builder() .id(UUID.randomUUID()) - .customerId(1) + .customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")) .duration(null) .paymentMethod("NullTest") .debutDate("2025-06-08") @@ -89,15 +90,12 @@ public class SubscriptionConverterTest { @Test @DisplayName("Should preserve empty string values during conversion") void shouldPreserveEmptyStrings() { - SubscriptionInfo subscriptionInfo = new SubscriptionInfo("", "", "", ""); + SubscriptionInfo subscriptionInfo = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, ""); Subscription domainResult = SubscriptionConverter.toDomain(subscriptionInfo); SubscriptionDTO dtoResult = SubscriptionConverter.toDTO(domainResult); - assertEquals("", dtoResult.getCustomerId()); - assertEquals("", dtoResult.getDuration()); assertEquals("", dtoResult.getPaymentMethod()); - assertEquals("", dtoResult.getDebutDate()); } } } diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java index 99c0098..ea79f4d 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java @@ -14,7 +14,7 @@ public class SubscriptionTest { @DisplayName("Builder should create a valid Subscription instance") void testSubscriptionBuilder() { UUID id = UUID.randomUUID(); - int customerId = 1; + UUID customerId = UUID.fromString("123e4567-e89b-12d3-a456-426614174000"); int duration = 12; String paymentMethod = "CB"; String debutDate = "2025-06-08"; 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 index a01acbe..83ea5b2 100644 --- 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 @@ -1,7 +1,7 @@ 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.customer.repository.CustomerRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -25,18 +25,16 @@ public class SubscriptionRepositoryTest { repository = new SubscriptionRepository(); Subscription1 = Subscription.builder() - .customerId(1) + .customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")) .duration(12) .paymentMethod("CB") - .debutDate("2025-06-10") .build(); Subscription1.setRandomUUID(); Subscription2 = Subscription.builder() - .customerId(2) + .customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")) .duration(24) .paymentMethod("Paypal") - .debutDate("2025-06-11") .build(); Subscription2.setRandomUUID(); } @@ -47,7 +45,7 @@ public class SubscriptionRepositoryTest { List subscriptions = repository.findAll(); assertTrue(subscriptions.isEmpty()); - assertEquals(0, subsciptions.size()); + assertEquals(0, subscriptions.size()); } @Nested @@ -57,24 +55,24 @@ public class SubscriptionRepositoryTest { @Test @DisplayName("Save should add a new subsciption") void testSaveNewSubscription() { - Subscription savedSubscription = repository.save(subscription1); + Subscription savedSubscription = repository.save(Subscription1); assertEquals(1, repository.findAll().size()); - assertEquals(subscription1.getId(), savedSubscription.getId()); - assertEquals(subscription1.getDebutDate(), savedSubscription.getDebutDate()); + assertEquals(Subscription1.getId(), savedSubscription.getId()); + assertEquals(Subscription1.getDebutDate(), savedSubscription.getDebutDate()); } @Test @DisplayName("Save multiple Subscriptions should add all of them") void testSaveMultipleSubscriptions() { - repository.save(subscription1); - repository.save(subscription2); + repository.save(Subscription1); + repository.save(Subscription2); List subscriptions = repository.findAll(); assertEquals(2, subscriptions.size()); - assertTrue(subscriptions.contains(subscription1)); - assertTrue(subscriptions.contains(subscription2)); + assertTrue(subscriptions.contains(Subscription1)); + assertTrue(subscriptions.contains(Subscription2)); } } @@ -84,8 +82,8 @@ public class SubscriptionRepositoryTest { @BeforeEach void setUpSubscriptions() { - repository.save(subscription1); - repository.save(subscription2); + repository.save(Subscription1); + repository.save(Subscription2); } @Test @@ -94,18 +92,18 @@ public class SubscriptionRepositoryTest { List subscriptions = repository.findAll(); assertEquals(2, subscriptions.size()); - assertTrue(subscriptions.contains(subscription1)); - assertTrue(subscriptions.contains(subscription2)); + assertTrue(subscriptions.contains(Subscription1)); + assertTrue(subscriptions.contains(Subscription2)); } @Test @DisplayName("FindById should return subscriptions with matching ID") void testFindById() { - Optional foundSubscription = repository.findById(subscription1.getId()); + Optional foundSubscription = repository.findByCustomerId(Subscription1.getId()); assertTrue(foundSubscription.isPresent()); - assertEquals(subscription1.getFirstName(), foundSubscription.get().getId()); - assertEquals(subscription1.getLastName(), foundSubscription.get().getCustomerId()); + assertEquals(Subscription1.getId(), foundSubscription.get().getId()); + assertEquals(Subscription1.getCustomerId(), foundSubscription.get().getCustomerId()); } @Test @@ -113,7 +111,7 @@ public class SubscriptionRepositoryTest { void testFindByIdNotFound() { UUID nonExistentId = UUID.randomUUID(); - Optional foundSubscription = repository.findById(nonExistentId); + Optional foundSubscription = repository.findByCustomerId(nonExistentId); assertTrue(foundSubscription.isEmpty()); } @@ -121,17 +119,17 @@ public class SubscriptionRepositoryTest { @Test @DisplayName("FindByCustomerId should return customer with matching customer id") void testFindByCustomerId() { - Optional foundSubscription = repository.findByCustomerId("1"); + Optional foundSubscription = repository.findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")); assertTrue(foundSubscription.isPresent()); - assertEquals(subscription1.getId(), foundSubscription.get().getId()); - assertEquals(subscription1.getDebutDate(), foundSubscription.get().getDebutDate()); + assertEquals(Subscription1.getId(), foundSubscription.get().getId()); + assertEquals(Subscription1.getDebutDate(), foundSubscription.get().getDebutDate()); } @Test @DisplayName("FindByCustomerId should return empty Optional when phone number doesn't exist") void testFindByPhoneNumberNotFound() { - Optional foundSubscription = repository.findByCustomerId("0"); + Optional foundSubscription = repository.findByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000")); assertTrue(foundSubscription.isEmpty()); } @@ -139,7 +137,7 @@ public class SubscriptionRepositoryTest { @Test @DisplayName("ExistsById should return true when ID exists") void testExistsByIdExists() { - boolean exists = repository.existsById(subscription1.getId()); + boolean exists = repository.existsById(Subscription1.getId()); assertTrue(exists); } diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java index e4fb30f..85eba94 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java @@ -1,13 +1,12 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionDTO; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionInfo; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.entity.Subscription; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.SubscriptionNotFoundException; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.IllegalSubscriptionPointException; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.NotValidSubscriptionException; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.repository.SubscriptionRepository; -import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.usecase.SubscriptionUseCase; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.SubscriptionNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase.SubscriptionUseCase; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -42,13 +41,12 @@ public class SubscribeUseCaseTest { subscriptionId = UUID.randomUUID(); testSubscription = Subscription.builder() .id(subscriptionId) - .CustomerId(1) + .customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")) .duration(12) - .phaymentMethod("CB") - .debutDate("2025-06-10") + .paymentMethod("CB") .build(); - validSubscriptionInfo = new SubscriptionInfo("1", "12", "CB", "2025-06-08"); + validSubscriptionInfo = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "CB"); } @Nested @@ -70,7 +68,7 @@ public class SubscribeUseCaseTest { @Test @DisplayName("Should throw exception when subscription data is not valid") void testRegisterSubscriptionWithInvalidData() { - SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo("", "", ""); + SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo(null, null, ""); assertThrows(NotValidSubscriptionException.class, () -> subscriptionUseCase.registerSubscription(invalidSubscriptionInfo)); @@ -86,25 +84,25 @@ public class SubscribeUseCaseTest { @Test @DisplayName("Should return subscription when phone number exists") void testFindSubscriptionByCustomerId() { - when(subscriptionRepository.findByCustomerId(1)).thenReturn(Optional.of(testSubscription)); + when(subscriptionRepository.findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"))).thenReturn(Optional.of(testSubscription)); - Optional foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(1); + Optional foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")); assertTrue(foundSubscription.isPresent()); assertEquals(testSubscription.getId(), foundSubscription.get().getId()); assertEquals(testSubscription.getDebutDate(), foundSubscription.get().getDebutDate()); - verify(subscriptionRepository, times(1)).findByCustomerId(1); + verify(subscriptionRepository, times(1)).findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000")); } @Test @DisplayName("Should return empty Optional when phone number doesn't exist") void testFindSubscriptionByPhoneNumberNotFound() { - when(subscriptionRepository.findByCustomerId(0)).thenReturn(Optional.empty()); + when(subscriptionRepository.findByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000"))).thenReturn(Optional.empty()); - Optional foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(0); + Optional foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000")); assertTrue(foundSubscription.isEmpty()); - verify(subscriptionRepository, times(1)).findByCustomerId(0); + verify(subscriptionRepository, times(1)).findByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000")); } } diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java index 296d420..7343e8c 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java @@ -1,8 +1,5 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.SubscriptionValidator; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException; import org.junit.jupiter.api.DisplayName; @@ -11,6 +8,8 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; +import java.util.UUID; + import static org.junit.jupiter.api.Assertions.*; public class SubscriptionValidatorTest { @@ -18,7 +17,7 @@ public class SubscriptionValidatorTest { @Test @DisplayName("Should validate subscription with valid data") void testValidateValidSubscription() { - SubscriptionInfo validSubscription = new SubscriptionInfo("1", "12", "CB", "2025-06-08"); + SubscriptionInfo validSubscription = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "CB"); assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); } @@ -30,21 +29,22 @@ public class SubscriptionValidatorTest { @Test @DisplayName("Should throw exception when customer id is blank") void testValidateBlankCustomerId() { - SubscriptionInfo subscriptionWithBlankCustomerId = new SubscriptionInfo("", "12", "CB", "2025-06-08"); + SubscriptionInfo subscriptionWithBlankCustomerId = new SubscriptionInfo(null, 12, "CB"); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, () -> SubscriptionValidator.validate(subscriptionWithBlankCustomerId) ); - assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_BLANK, exception.getMessage()); + assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_NULL, + exception.getMessage()); } - @ParameterizedTest + /**@ParameterizedTest @ValueSource(strings = {" ", " ", "\t", "\n"}) @DisplayName("Should throw exception when customer id contains only whitespace") void testValidateWhitespaceCustomerId(String whitespace) { - SubscriptionInfo subscriptionWithWhitespaceFirstName = new SubscriptionInfo(whitespace, "12", "CB", "2025-06-08"); + SubscriptionInfo subscriptionWithWhitespaceFirstName = new SubscriptionInfo(whitespace, 12, "CB"); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, @@ -52,7 +52,7 @@ public class SubscriptionValidatorTest { ); assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_BLANK, exception.getMessage()); - } + }**/ } @Nested @@ -62,21 +62,21 @@ public class SubscriptionValidatorTest { @Test @DisplayName("Should throw exception when duration is blank") void testValidateBlankDuration() { - SubscriptionInfo subscriptionWithBlankDuration = new SubscriptionInfo("1", "", "CB", "2025-06-08"); + SubscriptionInfo subscriptionWithBlankDuration = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), null, "CB"); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, () -> SubscriptionValidator.validate(subscriptionWithBlankDuration) ); - assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_BLANK, exception.getMessage()); + assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_NULL, exception.getMessage()); } - @ParameterizedTest + /**@ParameterizedTest @ValueSource(strings = {" ", " ", "\t", "\n"}) @DisplayName("Should throw exception when last name contains only whitespace") void testValidateWhitespaceDuration(String whitespace) { - SubscriptionInfo subscriptionWithWhitespaceDuration = new SubscriptionInfo("1", whitespace, "CB", "2025-06-08"); + SubscriptionInfo subscriptionWithWhitespaceDuration = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), whitespace, "CB"); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, @@ -84,7 +84,7 @@ public class SubscriptionValidatorTest { ); assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_BLANK, exception.getMessage()); - } + }**/ } @Nested @@ -94,7 +94,7 @@ public class SubscriptionValidatorTest { @Test @DisplayName("Should throw exception when payment method is blank") void testValidateBlankPaymentMethod() { - SubscriptionInfo subscriptionWithBlankPaymentMethod = new SubscriptionInfo("1", "12", "", "2025-06-08"); + SubscriptionInfo subscriptionWithBlankPaymentMethod = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, ""); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, @@ -108,7 +108,7 @@ public class SubscriptionValidatorTest { @ValueSource(strings = {" ", " ", "\t", "\n"}) @DisplayName("Should throw exception when payment method contains only whitespace") void testValidateWhitespacePhoneNumber(String whitespace) { - SubscriptionInfo subscriptionWithWhitespacePhoneNumber = new SubscriptionInfo("1", "12", whitespace, "2025-06-08"); + SubscriptionInfo subscriptionWithWhitespacePaymentMethod = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, whitespace); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, diff --git a/src/test/resources/features/subscription.feature b/src/test/resources/features/subscription.feature index ddc7606..ea84780 100644 --- a/src/test/resources/features/subscription.feature +++ b/src/test/resources/features/subscription.feature @@ -3,26 +3,26 @@ Feature: Manage customer subscription Background: Given the system has the following customers: - | customerId | firstName | lastNale | phoneNumer | loyaltyPoints | - | 1 | John | Doe | 0612345678 | 100 | - | 2 | Bob | Dupond | 0687654321 | 50 | - | 3 | Alice | Untel | 0698765432 | 0 | + | customerId | firstName | lastName | phoneNumer | pointsFidelite | + | 11111111-1111-1111-1111-111111111111 | John | Doe | 0612345678 | 100 | + | 22222222-2222-2222-2222-222222222222 | Bob | Dupond | 0687654321 | 50 | + | 33333333-3333-3333-3333-333333333333 | Alice | Untel | 0698765432 | 0 | Scenario: Create a new subscription When I create a new subscription with CB: - | customerId | duration | paymentMethod | debutDate | - | 1 | 12 | CB | 2025-06-10 | + | customerId | duration | paymentMethod | + | 11111111-1111-1111-1111-111111111111 | 12 | CB | Then a new subscription is created Scenario: Create a new subscription When I create a new subscription with Paypal: - | customerId | duration | paymentMethod | debutDate | - | 2 | 24 | Paypal | 2025-06-11 | + | customerId | duration | paymentMethod | + | 22222222-2222-2222-2222-222222222222 | 24 | Paypal | Then a new subscription is created Scenario: Attempt to create a subscription with invalid duration: When I try to create a new subscription with the following information: - | customerId | duration | paymentMethod | debutDate | - | 3 | 0 | CB | 2025-06-12 | + | customerId | duration | paymentMethod | + | 33333333-3333-3333-3333-333333333333 | 0 | CB | Then the subsription duration creation fails And I receive an error for validation subscription message containing "Duration must be positive" \ No newline at end of file