subscription passe !

.idea/encodings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="file://$PROJECT_DIR$/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/src/main/resources" charset="UTF-8" />
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="MavenProjectsManager">
+    <option name="originalFiles">
+      <list>
+        <option value="$PROJECT_DIR$/pom.xml" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="openjdk-23" project-jdk-type="JavaSDK" />
+</project>

.idea/vcs.xml

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="VcsDirectoryMappings" defaultProject="true" />
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
 </project>

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;
+}

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) {
+
+}

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();
+    }
+
+}

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();
+    }
+}

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);
+    }
+}

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));
+    }
+}

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<Subscription> subscriptions = new ArrayList<>();
+
+    public List<Subscription> findAll() {
+        return subscriptions;
+    }
+
+    public Subscription save(Subscription newSubscription) {
+        Optional<Subscription> optionalSubscriptionWithSameId = this.findByCustomerId(newSubscription.getCustomerId());
+        optionalSubscriptionWithSameId.ifPresentOrElse(subscriptions::remove, newSubscription::setRandomUUID);
+        this.subscriptions.add(newSubscription);
+        return newSubscription;
+    }
+
+    public Optional<Subscription> 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));
+    }
+
+}

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<SubscriptionDTO> findSubscriptionByCustomerId(UUID customerId) {
+        Optional<Subscription> 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);
+    }
+
+}

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);
+        }
+    }
+
+}

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<String, UUID> 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<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
 
-        Map<String, String> customerInfo = rows.getFirst();
+        // Extract the first row of data
+        Map<String, String> subscriptionData = rows.getFirst();
 
-        SubscriptionInfo newSubscription = new subscriptionInfo(
+        // Create a new SubscriptionInfo object with the correct keys
-                subscriptionInfo.get("customerId"),
+        SubscriptionInfo newSubscription = new SubscriptionInfo(
-                subscriptionInfo.get("duration"),
+                UUID.fromString(subscriptionData.get("customerId")),
-                subscriptionInfo.get("paymentMethod"),
+                Integer.parseInt(subscriptionData.get("duration")),
-                subscriptionInfo.get("debutDate")
+                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<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
 
-        Map<String, String> customerInfo = rows.getFirst();
+        // Extract the first row of data
+        Map<String, String> subscriptionData = rows.getFirst();
 
-        SubscriptionInfo newSubscription = new subscriptionInfo(
+        // Create a new SubscriptionInfo object with the correct keys
-                subscriptionInfo.get("customerId"),
+        SubscriptionInfo newSubscription = new SubscriptionInfo(
-                subscriptionInfo.get("duration"),
+                UUID.fromString(subscriptionData.get("customerId")),
-                subscriptionInfo.get("paymentMethod"),
+                Integer.parseInt(subscriptionData.get("duration")),
-                subscriptionInfo.get("debutDate")
+                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<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
 
-        Map<String, String> customerInfo = rows.getFirst();
+        Map<String, String> subscriptionData = rows.getFirst();
 
-        SubscriptionInfo newSubscription = new subscriptionInfo(
+        SubscriptionInfo newSubscription = new SubscriptionInfo(
-                subscriptionInfo.get("customerId"),
+                UUID.fromString(subscriptionData.get("customerId")),
-                subscriptionInfo.get("duration"),
+                Integer.parseInt(subscriptionData.get("duration")),
-                subscriptionInfo.get("paymentMethod"),
+                subscriptionData.get("paymentMethod")
-                subscriptionInfo.get("debutDate")
         );
 
-        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());
     }
 }

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.subscription.entity.Subscription;
-import fr.iut_fbleau.but3.dev62.mylibrary.customer.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());
         }
     }
 }

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";

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.subscription.entity.Subscription;
-import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
+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<Subscription> 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.getId(), savedSubscription.getId());
-            assertEquals(subscription1.getDebutDate(), savedSubscription.getDebutDate());
+            assertEquals(Subscription1.getDebutDate(), savedSubscription.getDebutDate());
         }
 
         @Test
         @DisplayName("Save multiple Subscriptions should add all of them")
         void testSaveMultipleSubscriptions() {
-            repository.save(subscription1);
+            repository.save(Subscription1);
-            repository.save(subscription2);
+            repository.save(Subscription2);
 
             List<Subscription> subscriptions = repository.findAll();
 
             assertEquals(2, subscriptions.size());
-            assertTrue(subscriptions.contains(subscription1));
+            assertTrue(subscriptions.contains(Subscription1));
-            assertTrue(subscriptions.contains(subscription2));
+            assertTrue(subscriptions.contains(Subscription2));
         }
     }
 
@@ -84,8 +82,8 @@ public class SubscriptionRepositoryTest {
 
         @BeforeEach
         void setUpSubscriptions() {
-            repository.save(subscription1);
+            repository.save(Subscription1);
-            repository.save(subscription2);
+            repository.save(Subscription2);
         }
 
         @Test
@@ -94,18 +92,18 @@ public class SubscriptionRepositoryTest {
             List<Subscription> subscriptions = repository.findAll();
 
             assertEquals(2, subscriptions.size());
-            assertTrue(subscriptions.contains(subscription1));
+            assertTrue(subscriptions.contains(Subscription1));
-            assertTrue(subscriptions.contains(subscription2));
+            assertTrue(subscriptions.contains(Subscription2));
         }
 
         @Test
         @DisplayName("FindById should return subscriptions with matching ID")
         void testFindById() {
-            Optional<Subsciption> foundSubscription = repository.findById(subscription1.getId());
+            Optional<Subscription> foundSubscription = repository.findByCustomerId(Subscription1.getId());
 
             assertTrue(foundSubscription.isPresent());
-            assertEquals(subscription1.getFirstName(), foundSubscription.get().getId());
+            assertEquals(Subscription1.getId(), foundSubscription.get().getId());
-            assertEquals(subscription1.getLastName(), foundSubscription.get().getCustomerId());
+            assertEquals(Subscription1.getCustomerId(), foundSubscription.get().getCustomerId());
         }
 
         @Test
@@ -113,7 +111,7 @@ public class SubscriptionRepositoryTest {
         void testFindByIdNotFound() {
             UUID nonExistentId = UUID.randomUUID();
 
-            Optional<Subscription> foundSubscription = repository.findById(nonExistentId);
+            Optional<Subscription> 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<Subscription> foundSubscription = repository.findByCustomerId("1");
+            Optional<Subscription> foundSubscription = repository.findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"));
 
             assertTrue(foundSubscription.isPresent());
-            assertEquals(subscription1.getId(), foundSubscription.get().getId());
+            assertEquals(Subscription1.getId(), foundSubscription.get().getId());
-            assertEquals(subscription1.getDebutDate(), foundSubscription.get().getDebutDate());
+            assertEquals(Subscription1.getDebutDate(), foundSubscription.get().getDebutDate());
         }
 
         @Test
         @DisplayName("FindByCustomerId should return empty Optional when phone number doesn't exist")
         void testFindByPhoneNumberNotFound() {
-            Optional<Subscription> foundSubscription = repository.findByCustomerId("0");
+            Optional<Subscription> 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);
         }

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.SubscriptionDTO;
-import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionInfo;
+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.entity.Subscription;
-import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.SubscriptionNotFoundException;
+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.exception.NotValidSubscriptionException;
+import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository;
-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.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")
+                .paymentMethod("CB")
-                .debutDate("2025-06-10")
                 .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<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(1);
+            Optional<SubscriptionDTO> 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<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(0);
+            Optional<SubscriptionDTO> 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"));
         }
     }
     

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,

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 |
+      | customerId                           | firstName | lastName | phoneNumer | pointsFidelite |
-    | 1          |  John     |   Doe    | 0612345678 | 100           |
+      | 11111111-1111-1111-1111-111111111111 | John      | Doe      | 0612345678 | 100            |
-    | 2          |    Bob    |  Dupond  | 0687654321 | 50            |
+      | 22222222-2222-2222-2222-222222222222 | Bob       | Dupond   | 0687654321 | 50             |
-    | 3          |  Alice    |   Untel  | 0698765432 | 0             |
+      | 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  |
+      | customerId                           | duration | paymentMethod |
-    |      1     |    12    |      CB       | 2025-06-10 |
+      | 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  |
+      | customerId                           | duration | paymentMethod |
-      |      2     |    24    |    Paypal     | 2025-06-11 |
+      | 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  |
+      | customerId                           | duration | paymentMethod |
-      |      3     |    0    |      CB       | 2025-06-12 |
+      | 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"