From da19dfcbac6c3e4dcf3199c2f5cef551e64848d5 Mon Sep 17 00:00:00 2001 From: aubert Date: Sat, 13 Jun 2026 15:08:34 +0200 Subject: [PATCH 01/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20cr=C3=A9ation=20?= =?UTF-8?q?des=20tests=20de=20converter=20et=20de=20entity=20pour=20subscr?= =?UTF-8?q?iption=20et=20paymentmethod?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../converter/SubscriptionConverterTest.java | 122 +++++++++++++++++ .../entity/PaymentMethodTest.java | 57 ++++++++ .../subscription/entity/SubscriptionTest.java | 123 ++++++++++++++++++ 3 files changed, 302 insertions(+) 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/PaymentMethodTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java 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..4554a3c --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java @@ -0,0 +1,122 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.time.LocalDate; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +public class SubscriptionConverterTest { + + @Nested + @DisplayName("toDomain() method tests") + class ToDomainTests { + + @Test + @DisplayName("Should convert SubscriptionInfo to Subscription domain object with monthly amount initialized to 0") + void shouldConvertSubscriptionInfoToDomain() { + // Given + PaymentMethodInfo paymentMethodInfo = new PaymentMethodInfo(PaymentType.CB.name(), "Maxime Lebreton"); + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + SubscriptionInfo subscriptionInfo = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + + // When + Subscription result = SubscriptionConverter.toDomain(subscriptionInfo, paymentMethodInfo); + + // Then + assertNotNull(result); + assertEquals(subscriptionInfo.subscriptionDurationDesired(), result.getSubscriptionDurationDesired()); + assertEquals(paymentMethodInfo.paymentType(), result.getPaymentMethod().getPaymentType()); + assertEquals(paymentMethodInfo.details(), result.getPaymentMethod().getDetails()); + assertEquals(subscriptionInfo.desiredStartDate(), result.getDesiredStartDate()); + assertEquals(subscriptionInfo.desiredStartDate(), result.getStartDate()); + assertEquals(estimateEndDate, result.getEndDate()); + assertEquals(0, result.getMonthlyAmount()); + } + } + + @Nested + @DisplayName("toDTO() method tests") + class ToDTOTests { + + @Test + @DisplayName("Should convert Subscription domain object to SubscriptionDTO with all fields mapped correctly") + void shouldConvertSubscriptionToDTO() { + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(PaymentType.CB.name()) + .details("Maxime Lebreton") + .build(); + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + Subscription subscription = Subscription.builder() + .subscriptionId(UUID.randomUUID()) + .customerId(UUID.randomUUID()) + .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .startDate(desiredStartDate) + .endDate(estimateEndDate) + .monthlyAmount(12.03) + .build(); + + SubscriptionDTO result = SubscriptionConverter.toDTO(subscription); + + assertNotNull(result); + assertEquals(subscription.getSubscriptionId(), result.getSubscriptionId()); + assertEquals(subscription.getCustomerId(), result.getCustomerId()); + assertEquals(subscription.getSubscriptionDurationDesired(), result.getSubscriptionDurationDesired()); + assertEquals(subscription.getPaymentMethod().getPaymentType(), result.getPaymentMethod().getPaymentType()); + assertEquals(subscription.getPaymentMethod().getDetails(), result.getPaymentMethod().getDetails()); + assertEquals(subscription.desiredStartDate(), result.getStartDateDesired()); + assertEquals(subscription.getStartDate(), result.getStartDate()); + assertEquals(subscription.getEndDate(), result.getEndDate()); + assertEquals(12.03, result.getMonthlyAmount()); + } + } + + @Test + @DisplayName("Should handle null values properly when converting between objects") + void shouldHandleNullValuesGracefully() { + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(PaymentType.CB.name()) + .details(null) + .build(); + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + Subscription subscription = Subscription.builder() + .subscriptionId(UUID.randomUUID()) + .customerId(UUID.randomUUID()) + .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .startDate(desiredStartDate) + .endDate(estimateEndDate) + .monthlyAmount(12.03) + .build(); + + SubscriptionDTO result = SubscriptionConverter.toDTO(customer); + + assertNotNull(result); + assertNull(result.getPaymentMethod().getDetails()); + assertEquals(desiredStartDate, result.getDesiredStartDate()); + } + + @Test + @DisplayName("Should preserve empty string values during conversion") + void shouldPreserveEmptyStrings() { + PaymentMethodInfo paymentMethodInfo = new PaymentMethodInfo(PaymentType.CB.name(), ""); + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + SubscriptionInfo subscriptionInfo = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + + Subscription domainResult = SubscriptionConverter.toDomain(subscriptionInfo, paymentMethodInfo); + SubscriptionDTO dtoResult = SubscriptionConverter.toDTO(domainResult); + + assertEquals("", dtoResult.getPaymentMethod().getDetails()); + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java new file mode 100644 index 0000000..bf95192 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java @@ -0,0 +1,57 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class PaymentMethodTest { + + @Test + @DisplayName("Builder should create a valid Subscription instance") + void testSubscriptionBuilder() { + String paymentType = PaymentType.CB.name(); + Object details = new Object(); + details = "Maxime Lebreton"; + + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(paymentType) + .details(details) + .build(); + + assertEquals(paymentType, paymentMethod.getPaymentType()); + assertEquals(details, paymentMethod.getDetails()); + } + + @Test + @DisplayName("Builder should create a valid Subscription instance with details as an Integer") + void testSubscriptionBuilder() { + String paymentType = PaymentType.CB.name(); + Object details = new Object(); + details = 10; + + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(paymentType) + .details(details) + .build(); + + assertEquals(paymentType, paymentMethod.getPaymentType()); + assertEquals(details, paymentMethod.getDetails()); + } + + @Test + @DisplayName("Builder should create a valid Subscription instance with details as an boolean") + void testSubscriptionBuilder() { + String paymentType = PaymentType.CB.name(); + Object details = new Object(); + details = true; + + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(paymentType) + .details(details) + .build(); + + assertEquals(paymentType, paymentMethod.getPaymentType()); + assertEquals(details, paymentMethod.getDetails()); + } +} 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..40c2b45 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java @@ -0,0 +1,123 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.time.LocalDate; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class SubscriptionTest { + + @Test + @DisplayName("Builder should create a valid Subscription instance") + void testSubscriptionBuilder() { + UUID subscriptionId = UUID.randomUUID(); + UUID customerId = UUID.randomUUID(); + Integer subscriptionDurationDesired = SubscriptionDurationDesired.THREE.getValue(); + String paymentType = PaymentType.CB.name(); + Object details = new Object(); + details = "Maxime Lebreton"; + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate startDate = desiredStartDate; + LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + double monthlyAmount = 17.99; + + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(paymentType) + .details(details) + .build(); + Subscription subscription = Subscription.builder() + .subscriptionId(subscriptionId) + .customerId(customerId) + .subscriptionDurationDesired(subscriptionDurationDesired) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .startDate(startDate) + .endDate(estimateEndDate) + .monthlyAmount(monthlyAmount) + .build(); + + assertEquals(subscriptionId, subscription.getSubscriptionId()); + assertEquals(customerId, subscription.getCustomerId()); + assertEquals(subscriptionDurationDesired, subscription.getSubscriptionDurationDesired()); + assertEquals(paymentType, paymentMethod.getPaymentType()); + assertEquals(details, paymentMethod.getDetails()); + assertEquals(desiredStartDate, subscription.getDesiredStartDate()); + assertEquals(startDate, subscription.getStartDate()); + assertEquals(estimateEndDate, subscription.getEndDate()); + assertEquals(monthlyAmount, subscription.getMonthlyAmount()); + } + + @Test + @DisplayName("setRandomSubscriptionUUID should change the ID to a new random UUID") + void testSetRandomSubscriptionUUID() { + Subscription subscription = Subscription.builder().build(); + UUID originalId = subscription.getSubscriptionId(); + + subscription.setRandomSubscriptionUUID(); + + assertNotNull(subscription.getSubscriptionId()); + assertNotEquals(originalId, subscription.getSubscriptionId()); + } + + @Test + @DisplayName("setRandomCustomerUUID should change the ID to a new random UUID") + void testSetRandomCustomerUUID() { + Subscription subscription = Subscription.builder().build(); + UUID originalId = subscription.getCustomerId(); + + Subscription.setRandomCustomerUUID(); + + assertNotNull(subscription.getCustomerId()); + assertNotEquals(originalId, subscription.getCustomerId()); + } + + @Test + @DisplayName("setStartDate should instantiate StartDate as the same value as the variable desiredStartDate") + void testSetRandomCustomerUUID() { + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + Subscription subscription = Subscription.builder() + .desiredStartDate(desiredStartDate) + .build(); + + Subscription.setStartDate(); + + assertNotNull(subscription.getStartDate()); + assertEquals(desiredStartDate, subscription.getStartDate()); + } + + @Test + @DisplayName("setEndDate should instantiate EndDate as the same value as the variable desiredStartDate + subscriptionDurationDesired") + void testSetRandomCustomerUUID() { + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + Subscription subscription = Subscription.builder() + .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .desiredStartDate(desiredStartDate) + .build(); + + Subscription.setEndDate(); + + assertNotNull(subscription.getEndDate()); + assertEquals(estimateEndDate, subscription.getEndDate()); + } + + @Test + @DisplayName("setDateSubscription should instantiate StartDate and EndDate ") + void testSetRandomCustomerUUID() { + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + Subscription subscription = Subscription.builder() + .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .desiredStartDate(desiredStartDate) + .build(); + + Subscription.setDateSubscription(); + + assertNotNull(subscription.getEndDate()); + assertEquals(estimateEndDate, subscription.getEndDate()); + } +} -- 2.54.0 From 5d5945b48ba4b337e0b16224bf98506125775861 Mon Sep 17 00:00:00 2001 From: aubert Date: Sat, 13 Jun 2026 16:00:03 +0200 Subject: [PATCH 02/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20r=C3=A9ussite=20?= =?UTF-8?q?des=20tests=20de=20base,=20c'=C3=A9tait=20long?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../subscription/PaymentMethodInfo.java | 4 ++ .../mylibrary/subscription/PaymentType.java | 6 +++ .../subscription/SubscriptionDTO.java | 22 ++++++++++ .../SubscriptionDurationDesired.java | 17 +++++++ .../subscription/SubscriptionInfo.java | 6 +++ .../converter/SubscriptionConverter.java | 43 ++++++++++++++++++ .../subscription/entity/PaymentMethod.java | 12 +++++ .../subscription/entity/Subscription.java | 44 +++++++++++++++++++ .../converter/SubscriptionConverterTest.java | 7 ++- .../entity/PaymentMethodTest.java | 13 +++--- .../subscription/entity/SubscriptionTest.java | 16 ++++--- 11 files changed, 175 insertions(+), 15 deletions(-) create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentMethodInfo.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentType.java 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/SubscriptionDurationDesired.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/PaymentMethod.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentMethodInfo.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentMethodInfo.java new file mode 100644 index 0000000..23339a8 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentMethodInfo.java @@ -0,0 +1,4 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +public record PaymentMethodInfo(String paymentType, Object details) { +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentType.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentType.java new file mode 100644 index 0000000..701fafc --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/PaymentType.java @@ -0,0 +1,6 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +public enum PaymentType { + CB, + PAYPAL; +} 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..9637a56 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDTO.java @@ -0,0 +1,22 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; +import lombok.Builder; +import lombok.Getter; + +import java.time.LocalDate; +import java.util.UUID; + +@Builder +@Getter +public class SubscriptionDTO { + + private UUID subscriptionId; + private UUID customerId; + private Integer subscriptionDurationDesired; + private PaymentMethod paymentMethod; + private LocalDate desiredStartDate; + private LocalDate startDate; + private LocalDate endDate; + private double monthlyAmount; +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDurationDesired.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDurationDesired.java new file mode 100644 index 0000000..e244fba --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDurationDesired.java @@ -0,0 +1,17 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +public enum SubscriptionDurationDesired { + THREE(3), + SIX(6), + TWELVE(12); + + private final Integer value; + + SubscriptionDurationDesired(Integer value) { + this.value = value; + } + + public Integer getValue() { + return value; + } +} 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..fa0690f --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionInfo.java @@ -0,0 +1,6 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +import java.time.LocalDate; + +public record SubscriptionInfo(Integer subscriptionDurationDesired, LocalDate desiredStartDate) { +} 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..f5c00ca --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverter.java @@ -0,0 +1,43 @@ +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.subscription.PaymentMethodInfo; +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.PaymentMethod; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; + +public class SubscriptionConverter { + + private SubscriptionConverter(){ + + } + + public static Subscription toDomain(SubscriptionInfo newSubscription, PaymentMethodInfo newPaymentMethod) { + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(newPaymentMethod.paymentType()) + .details(newPaymentMethod.details()) + .build(); + return Subscription.builder() + .subscriptionDurationDesired(newSubscription.subscriptionDurationDesired()) + .paymentMethod(paymentMethod) + .desiredStartDate(newSubscription.desiredStartDate()) + .startDate(newSubscription.desiredStartDate()) + .endDate(newSubscription.desiredStartDate().plusMonths(newSubscription.subscriptionDurationDesired())) + .monthlyAmount(0) + .build(); + } + + public static SubscriptionDTO toDTO(Subscription subscription) { + return SubscriptionDTO.builder() + .subscriptionId(subscription.getSubscriptionId()) + .customerId(subscription.getCustomerId()) + .subscriptionDurationDesired(subscription.getSubscriptionDurationDesired()) + .paymentMethod(subscription.getPaymentMethod()) + .desiredStartDate(subscription.getDesiredStartDate()) + .startDate(subscription.getStartDate()) + .endDate(subscription.getEndDate()) + .monthlyAmount(subscription.getMonthlyAmount()) + .build(); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethod.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethod.java new file mode 100644 index 0000000..3828ba6 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethod.java @@ -0,0 +1,12 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; + +import lombok.Builder; +import lombok.Getter; + +@Builder +@Getter +public class PaymentMethod { + + private String paymentType; + private Object details; +} 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..b5e7d32 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java @@ -0,0 +1,44 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; + +import lombok.Builder; +import lombok.Getter; + +import java.time.LocalDate; +import java.util.UUID; + +@Builder +@Getter +public class Subscription { + + private UUID subscriptionId; + private UUID customerId; + private Integer subscriptionDurationDesired; + private PaymentMethod paymentMethod; + private LocalDate desiredStartDate; + private LocalDate startDate; + private LocalDate endDate; + private double monthlyAmount; + + public void setRandomSubscriptionUUID() { + + this.subscriptionId = UUID.randomUUID(); + } + + public void setRandomCustomerUUID() { + + this.customerId = UUID.randomUUID(); + } + + public void setStartDate(){ + this.startDate = this.desiredStartDate; + } + + public void setEndDate(){ + this.endDate = this.desiredStartDate.plusMonths(this.subscriptionDurationDesired); + } + + public void setDateSubscription(){ + setStartDate(); + setEndDate(); + } +} 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 4554a3c..4097c38 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 @@ -1,5 +1,8 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.*; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -73,7 +76,7 @@ public class SubscriptionConverterTest { assertEquals(subscription.getSubscriptionDurationDesired(), result.getSubscriptionDurationDesired()); assertEquals(subscription.getPaymentMethod().getPaymentType(), result.getPaymentMethod().getPaymentType()); assertEquals(subscription.getPaymentMethod().getDetails(), result.getPaymentMethod().getDetails()); - assertEquals(subscription.desiredStartDate(), result.getStartDateDesired()); + assertEquals(subscription.getDesiredStartDate(), result.getDesiredStartDate()); assertEquals(subscription.getStartDate(), result.getStartDate()); assertEquals(subscription.getEndDate(), result.getEndDate()); assertEquals(12.03, result.getMonthlyAmount()); @@ -100,7 +103,7 @@ public class SubscriptionConverterTest { .monthlyAmount(12.03) .build(); - SubscriptionDTO result = SubscriptionConverter.toDTO(customer); + SubscriptionDTO result = SubscriptionConverter.toDTO(subscription); assertNotNull(result); assertNull(result.getPaymentMethod().getDetails()); diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java index bf95192..4f184f5 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/PaymentMethodTest.java @@ -1,5 +1,6 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -8,8 +9,8 @@ import static org.junit.jupiter.api.Assertions.assertEquals; public class PaymentMethodTest { @Test - @DisplayName("Builder should create a valid Subscription instance") - void testSubscriptionBuilder() { + @DisplayName("Builder should create a valid PaymentMethod instance") + void testPaymentMethodBuilder() { String paymentType = PaymentType.CB.name(); Object details = new Object(); details = "Maxime Lebreton"; @@ -24,8 +25,8 @@ public class PaymentMethodTest { } @Test - @DisplayName("Builder should create a valid Subscription instance with details as an Integer") - void testSubscriptionBuilder() { + @DisplayName("Builder should create a valid PaymentMethod instance with details as an Integer") + void testPaymentMethodDetailsInteger() { String paymentType = PaymentType.CB.name(); Object details = new Object(); details = 10; @@ -40,8 +41,8 @@ public class PaymentMethodTest { } @Test - @DisplayName("Builder should create a valid Subscription instance with details as an boolean") - void testSubscriptionBuilder() { + @DisplayName("Builder should create a valid PaymentMethod instance with details as an boolean") + void testPaymentMethodDetailsBoolean() { String paymentType = PaymentType.CB.name(); Object details = new Object(); details = true; 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 40c2b45..ff34a7c 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 @@ -1,5 +1,7 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDurationDesired; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -69,7 +71,7 @@ public class SubscriptionTest { Subscription subscription = Subscription.builder().build(); UUID originalId = subscription.getCustomerId(); - Subscription.setRandomCustomerUUID(); + subscription.setRandomCustomerUUID(); assertNotNull(subscription.getCustomerId()); assertNotEquals(originalId, subscription.getCustomerId()); @@ -77,13 +79,13 @@ public class SubscriptionTest { @Test @DisplayName("setStartDate should instantiate StartDate as the same value as the variable desiredStartDate") - void testSetRandomCustomerUUID() { + void testSetStartDate() { LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); Subscription subscription = Subscription.builder() .desiredStartDate(desiredStartDate) .build(); - Subscription.setStartDate(); + subscription.setStartDate(); assertNotNull(subscription.getStartDate()); assertEquals(desiredStartDate, subscription.getStartDate()); @@ -91,7 +93,7 @@ public class SubscriptionTest { @Test @DisplayName("setEndDate should instantiate EndDate as the same value as the variable desiredStartDate + subscriptionDurationDesired") - void testSetRandomCustomerUUID() { + void testSetEndDate() { LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); Subscription subscription = Subscription.builder() @@ -99,7 +101,7 @@ public class SubscriptionTest { .desiredStartDate(desiredStartDate) .build(); - Subscription.setEndDate(); + subscription.setEndDate(); assertNotNull(subscription.getEndDate()); assertEquals(estimateEndDate, subscription.getEndDate()); @@ -107,7 +109,7 @@ public class SubscriptionTest { @Test @DisplayName("setDateSubscription should instantiate StartDate and EndDate ") - void testSetRandomCustomerUUID() { + void testSetDateSubscription() { LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); Subscription subscription = Subscription.builder() @@ -115,7 +117,7 @@ public class SubscriptionTest { .desiredStartDate(desiredStartDate) .build(); - Subscription.setDateSubscription(); + subscription.setDateSubscription(); assertNotNull(subscription.getEndDate()); assertEquals(estimateEndDate, subscription.getEndDate()); -- 2.54.0 From 2a6db599505dcee2ca1d1718f0faa9741bc2ccc6 Mon Sep 17 00:00:00 2001 From: aubert Date: Sat, 13 Jun 2026 22:41:47 +0200 Subject: [PATCH 03/11] =?UTF-8?q?mise=20=C3=A0=20jour=20pour=20correspondr?= =?UTF-8?q?e=20avec=20le=20fait=20que=20la=20date=20d=C3=A9sir=C3=A9=20de?= =?UTF-8?q?=20d=C3=A9but=20d'abonnement=20doit=20=C3=AAtre=20le=20jour=20m?= =?UTF-8?q?=C3=AAme=20ou=20plus=20tard?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../converter/SubscriptionConverterTest.java | 14 +++++++------- .../subscription/entity/SubscriptionTest.java | 14 +++++++------- 2 files changed, 14 insertions(+), 14 deletions(-) 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 4097c38..272f09f 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 @@ -25,9 +25,9 @@ public class SubscriptionConverterTest { void shouldConvertSubscriptionInfoToDomain() { // Given PaymentMethodInfo paymentMethodInfo = new PaymentMethodInfo(PaymentType.CB.name(), "Maxime Lebreton"); - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); SubscriptionInfo subscriptionInfo = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); - LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); // When Subscription result = SubscriptionConverter.toDomain(subscriptionInfo, paymentMethodInfo); @@ -55,8 +55,8 @@ public class SubscriptionConverterTest { .paymentType(PaymentType.CB.name()) .details("Maxime Lebreton") .build(); - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); - LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); Subscription subscription = Subscription.builder() .subscriptionId(UUID.randomUUID()) .customerId(UUID.randomUUID()) @@ -90,8 +90,8 @@ public class SubscriptionConverterTest { .paymentType(PaymentType.CB.name()) .details(null) .build(); - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); - LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); Subscription subscription = Subscription.builder() .subscriptionId(UUID.randomUUID()) .customerId(UUID.randomUUID()) @@ -114,7 +114,7 @@ public class SubscriptionConverterTest { @DisplayName("Should preserve empty string values during conversion") void shouldPreserveEmptyStrings() { PaymentMethodInfo paymentMethodInfo = new PaymentMethodInfo(PaymentType.CB.name(), ""); - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); SubscriptionInfo subscriptionInfo = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); Subscription domainResult = SubscriptionConverter.toDomain(subscriptionInfo, paymentMethodInfo); 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 ff34a7c..772f62b 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 @@ -22,9 +22,9 @@ public class SubscriptionTest { String paymentType = PaymentType.CB.name(); Object details = new Object(); details = "Maxime Lebreton"; - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); LocalDate startDate = desiredStartDate; - LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); double monthlyAmount = 17.99; PaymentMethod paymentMethod = PaymentMethod.builder() @@ -80,7 +80,7 @@ public class SubscriptionTest { @Test @DisplayName("setStartDate should instantiate StartDate as the same value as the variable desiredStartDate") void testSetStartDate() { - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); Subscription subscription = Subscription.builder() .desiredStartDate(desiredStartDate) .build(); @@ -94,8 +94,8 @@ public class SubscriptionTest { @Test @DisplayName("setEndDate should instantiate EndDate as the same value as the variable desiredStartDate + subscriptionDurationDesired") void testSetEndDate() { - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); - LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); Subscription subscription = Subscription.builder() .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) .desiredStartDate(desiredStartDate) @@ -110,8 +110,8 @@ public class SubscriptionTest { @Test @DisplayName("setDateSubscription should instantiate StartDate and EndDate ") void testSetDateSubscription() { - LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); - LocalDate estimateEndDate = LocalDate.of(2026, 6, 24); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); Subscription subscription = Subscription.builder() .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) .desiredStartDate(desiredStartDate) -- 2.54.0 From b2969260c0452327904c1ea24516651c401f07d1 Mon Sep 17 00:00:00 2001 From: aubert Date: Sat, 13 Jun 2026 23:22:40 +0200 Subject: [PATCH 04/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20cr=C3=A9ation=20?= =?UTF-8?q?des=20tests=20de=20validator?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../validator/PaymentMethodValidatorTest.java | 50 +++++++++++ .../validator/SubscriptionValidatorTest.java | 84 +++++++++++++++++++ 2 files changed, 134 insertions(+) create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java new file mode 100644 index 0000000..8ed39e9 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java @@ -0,0 +1,50 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentMethodInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; +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.EnumSource; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +public class PaymentMethodValidatorTest { + + @Test + @DisplayName("Should validate payment method with valid data") + void testValidateValidPaymentMethod() { + PaymentMethodInfo validPaymentMethod = new PaymentMethodInfo(PaymentType.CB.name(), "Maxime Lebreton"); + + assertDoesNotThrow(() -> PaymentMethodValidator.validate(validPaymentMethod)); + } + + @Nested + @DisplayName("PaymentType validation tests") + class PaymentTypeValidationTests { + + @ParameterizedTest + @EnumSource(value = PaymentType.class) + void testValidatePaymentType(PaymentType paymentType) { + String validPaymentType = paymentType.toString(); + PaymentMethodInfo validPaymentMethod = new PaymentMethodInfo(validPaymentType, "Maxime Lebreton"); + + assertDoesNotThrow(() -> PaymentMethodValidator.validate(validPaymentMethod)); + } + + @ParameterizedTest + @ValueSource(strings = {"jambon", " ", ""}) + void testNotValidatePaymentType(String invalidPaymentType) { + PaymentMethodInfo invalidPaymentMethod = new PaymentMethodInfo(invalidPaymentType, "Maxime Lebreton"); + + NotValidPaymentMethodException exception = assertThrows( + NotValidPaymentMethodException.class, + () -> PaymentMethodValidator.validate(invalidPaymentMethod) + ); + + assertEquals(PaymentMethodValidator.MODE_PAIEMENT_IS_NOT_VALIDE, exception.getMessage()); + } + } +} 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..c9d3d64 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java @@ -0,0 +1,84 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDurationDesired; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo; +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.EnumSource; + +import java.time.LocalDate; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class SubscriptionValidatorTest { + + @Test + @DisplayName("Should validate subscription with valid data") + void testValidateValidSubscription() { + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + SubscriptionInfo validSubscription = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + + assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); + } + + @Nested + @DisplayName("SubscriptionDurationDesired validation tests") + class SubscriptionDurationDesiredValidationTests { + + @ParameterizedTest + @EnumSource(value = SubscriptionDurationDesired.class) + void testValidateSubscriptionDurationDesired(SubscriptionDurationDesired subscriptionDurationDesired) { + Integer validSubscriptionDurationDesired = subscriptionDurationDesired.getValue(); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + SubscriptionInfo validSubscription = new SubscriptionInfo(validSubscriptionDurationDesired, desiredStartDate); + + assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); + } + + @Test + @DisplayName("Should throw exception when subscriptionDurationDesired is not 3, 6 or 12") + void testNotValidateSubscriptionDurationDesired() { + Integer notValidSubscriptionDurationDesired = 1 ; + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + SubscriptionInfo invalidSubscription = new SubscriptionInfo(notValidSubscriptionDurationDesired, desiredStartDate); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(invalidSubscription) + ); + assertEquals(SubscriptionValidator.SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALIDE, exception.getMessage()); + } + } + + @Nested + @DisplayName("DesiredStartDate validation tests") + class DesiredStartDateValidationTests { + + @Test + @DisplayName("Should validate when desiredStartDate is before today") + void testValidateDesiredStartDate() { + LocalDate desiredStartDate = LocalDate.now(); + SubscriptionInfo validSubscription = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + + assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); + } + + @Test + @DisplayName("Should throw exception when desiredStartDate is before today") + void testNotValidateDesiredStartDate() { + LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); + SubscriptionInfo validSubscription = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + + NotValidSubscriptionException exception = assertThrows( + NotValidSubscriptionException.class, + () -> SubscriptionValidator.validate(validSubscription) + ); + + assertEquals(SubscriptionValidator.DESIRED_START_DATE_CANNOT_BE_BEFORE_TODAY, exception.getMessage()); + } + } +} -- 2.54.0 From 9e69e020669c270581111b942ab8454682608afb Mon Sep 17 00:00:00 2001 From: aubert Date: Sun, 14 Jun 2026 00:00:18 +0200 Subject: [PATCH 05/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20cr=C3=A9ation=20?= =?UTF-8?q?des=20tests=20d'exception'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../NotValidPaymentMethodEsceptionTest.java | 58 ++++++++++++++++++ .../NotValidSubscriptionExceptionTest.java | 60 +++++++++++++++++++ 2 files changed, 118 insertions(+) create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodEsceptionTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodEsceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodEsceptionTest.java new file mode 100644 index 0000000..7ae5af4 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodEsceptionTest.java @@ -0,0 +1,58 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +import org.junit.jupiter.api.DisplayName; +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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class NotValidPaymentMethodEsceptionTest { + + @Test + @DisplayName("Exception should be created with the provided message") + void testExceptionCreation() { + String errorMessage = "PaymentMethod data is not valid"; + + NotValidPaymentMethodException exception = new NotValidPaymentMethodException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = { + "paymentType is not valid" + }) + @DisplayName("Exception should handle different validation messages") + void testExceptionWithDifferentMessages(String errorMessage) { + NotValidPaymentMethodException exception = new NotValidPaymentMethodException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + String errorMessage = "paymentType is not valid"; + + Exception exception = assertThrows(NotValidPaymentMethodException.class, () -> { + throw new NotValidPaymentMethodException(errorMessage); + }); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be catchable as a general Exception") + void testExceptionInheritance() { + String errorMessage = "Invalid paymentMethod data"; + + try { + throw new NotValidPaymentMethodException(errorMessage); + } catch (Exception e) { + assertEquals(NotValidPaymentMethodException.class, e.getClass()); + assertEquals(errorMessage, e.getMessage()); + } + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java new file mode 100644 index 0000000..a04d067 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java @@ -0,0 +1,60 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException; +import org.junit.jupiter.api.DisplayName; +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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class NotValidSubscriptionExceptionTest { + + @Test + @DisplayName("Exception should be created with the provided message") + void testExceptionCreation() { + String errorMessage = "Subscription data is not valid"; + + NotValidSubscriptionException exception = new NotValidSubscriptionException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = { + "subscriptionDurationDesired will be 3, 6 or 12 by the ENUM file SubscriptionDurationDesired", + "desiredStartDate cannot be before today" + }) + @DisplayName("Exception should handle different validation messages") + void testExceptionWithDifferentMessages(String errorMessage) { + NotValidSubscriptionException exception = new NotValidSubscriptionException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + String errorMessage = "desiredStartDate cannot be before today"; + + Exception exception = assertThrows(NotValidSubscriptionException.class, () -> { + throw new NotValidSubscriptionException(errorMessage); + }); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be catchable as a general Exception") + void testExceptionInheritance() { + String errorMessage = "Invalid subscription data"; + + try { + throw new NotValidSubscriptionException(errorMessage); + } catch (Exception e) { + assertEquals(NotValidSubscriptionException.class, e.getClass()); + assertEquals(errorMessage, e.getMessage()); + } + } +} -- 2.54.0 From 2c33798c8345771d69596a5a7f3aa09a3476e0e1 Mon Sep 17 00:00:00 2001 From: aubert Date: Sun, 14 Jun 2026 00:13:28 +0200 Subject: [PATCH 06/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20r=C3=A9ussite=20?= =?UTF-8?q?de=20tous=20les=20tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../NotValidPaymentMethodException.java | 8 +++++ .../NotValidSubscriptionException.java | 8 +++++ .../validator/PaymentMethodValidator.java | 27 ++++++++++++++ .../validator/SubscriptionValidator.java | 36 +++++++++++++++++++ .../validator/PaymentMethodValidatorTest.java | 3 +- .../validator/SubscriptionValidatorTest.java | 3 +- 6 files changed, 83 insertions(+), 2 deletions(-) create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodException.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/validator/PaymentMethodValidator.java create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodException.java new file mode 100644 index 0000000..7304eb9 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidPaymentMethodException.java @@ -0,0 +1,8 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +public class NotValidPaymentMethodException extends RuntimeException { + + public NotValidPaymentMethodException(String message) { + super(message); + } +} 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..27829f6 --- /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 RuntimeException { + + public NotValidSubscriptionException(String message) { + super(message); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidator.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidator.java new file mode 100644 index 0000000..a9c9590 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidator.java @@ -0,0 +1,27 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentMethodInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidPaymentMethodException; + +import java.util.Set; + +public class PaymentMethodValidator { + + public static final String MODE_PAIEMENT_IS_NOT_VALID = "paymentType is not valid"; + + private PaymentMethodValidator() { + + } + + public static void validate(PaymentMethodInfo newPaymentMethod) + throws NotValidPaymentMethodException { + validatePaymentType(newPaymentMethod); + } + + private static void validatePaymentType(PaymentMethodInfo newPaymentMethod) + throws NotValidPaymentMethodException { + Set Valid_Payment_Type = Set.of("CB", "PAYPAL"); + if (!Valid_Payment_Type.contains(newPaymentMethod.paymentType())) { + throw new NotValidPaymentMethodException(MODE_PAIEMENT_IS_NOT_VALID);} + } +} 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..7dd651f --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java @@ -0,0 +1,36 @@ +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 java.time.LocalDate; +import java.util.Set; + +public class SubscriptionValidator { + + public static final String SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALID = "subscriptionDurationDesired will be 3, 6 or 12 by the ENUM file SubscriptionDurationDesired"; + public static final String DESIRED_START_DATE_CANNOT_BE_BEFORE_TODAY = "desiredStartDate cannot be before today"; + + private SubscriptionValidator() { + + } + + public static void validate(SubscriptionInfo newSubscription) throws NotValidSubscriptionException { + validateDesiredStartDate(newSubscription); + validateSubscriptionDurationDesired(newSubscription); + } + + private static void validateSubscriptionDurationDesired(SubscriptionInfo newSubscription) + throws NotValidSubscriptionException { + Set VALID_DURATIONS = Set.of(3, 6, 12); + if (!VALID_DURATIONS.contains(newSubscription.subscriptionDurationDesired())) { + throw new NotValidSubscriptionException(SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALID);} + } + + private static void validateDesiredStartDate(SubscriptionInfo newSubscription) + throws NotValidSubscriptionException { + if (newSubscription.desiredStartDate().isBefore(LocalDate.now())) { + throw new NotValidSubscriptionException(DESIRED_START_DATE_CANNOT_BE_BEFORE_TODAY); + } + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java index 8ed39e9..5dc10be 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/PaymentMethodValidatorTest.java @@ -2,6 +2,7 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentMethodInfo; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidPaymentMethodException; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -44,7 +45,7 @@ public class PaymentMethodValidatorTest { () -> PaymentMethodValidator.validate(invalidPaymentMethod) ); - assertEquals(PaymentMethodValidator.MODE_PAIEMENT_IS_NOT_VALIDE, exception.getMessage()); + assertEquals(PaymentMethodValidator.MODE_PAIEMENT_IS_NOT_VALID, exception.getMessage()); } } } 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 c9d3d64..f5e0c91 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 @@ -2,6 +2,7 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDurationDesired; 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; @@ -50,7 +51,7 @@ public class SubscriptionValidatorTest { NotValidSubscriptionException.class, () -> SubscriptionValidator.validate(invalidSubscription) ); - assertEquals(SubscriptionValidator.SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALIDE, exception.getMessage()); + assertEquals(SubscriptionValidator.SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALID, exception.getMessage()); } } -- 2.54.0 From 5adb10101f6eb14c336aafad0804d6f380e2037f Mon Sep 17 00:00:00 2001 From: aubert Date: Sun, 14 Jun 2026 00:20:14 +0200 Subject: [PATCH 07/11] =?UTF-8?q?r=C3=A9utilisation=20de=20la=20m=C3=AAme?= =?UTF-8?q?=20commande=20que=20pour=20review=20parceque=20sinon=20trop=20l?= =?UTF-8?q?ong=20pour=20changer=20subscriptiondurationdesired=20en=20desir?= =?UTF-8?q?edsubscriptionduration?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...red.java => DesiredSubscriptionDuration.java} | 4 ++-- .../mylibrary/subscription/SubscriptionDTO.java | 2 +- .../mylibrary/subscription/SubscriptionInfo.java | 2 +- .../converter/SubscriptionConverter.java | 6 +++--- .../subscription/entity/Subscription.java | 4 ++-- .../validator/SubscriptionValidator.java | 4 ++-- .../converter/SubscriptionConverterTest.java | 12 ++++++------ .../subscription/entity/SubscriptionTest.java | 14 +++++++------- .../NotValidSubscriptionExceptionTest.java | 2 +- .../validator/SubscriptionValidatorTest.java | 16 ++++++++-------- 10 files changed, 33 insertions(+), 33 deletions(-) rename src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/{SubscriptionDurationDesired.java => DesiredSubscriptionDuration.java} (71%) diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDurationDesired.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/DesiredSubscriptionDuration.java similarity index 71% rename from src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDurationDesired.java rename to src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/DesiredSubscriptionDuration.java index e244fba..f216e3e 100644 --- a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDurationDesired.java +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/DesiredSubscriptionDuration.java @@ -1,13 +1,13 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription; -public enum SubscriptionDurationDesired { +public enum DesiredSubscriptionDuration { THREE(3), SIX(6), TWELVE(12); private final Integer value; - SubscriptionDurationDesired(Integer value) { + DesiredSubscriptionDuration(Integer value) { this.value = value; } 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 index 9637a56..cfb68a0 100644 --- 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 @@ -13,7 +13,7 @@ public class SubscriptionDTO { private UUID subscriptionId; private UUID customerId; - private Integer subscriptionDurationDesired; + private Integer desiredSubscriptionDuration; private PaymentMethod paymentMethod; private LocalDate desiredStartDate; private LocalDate startDate; 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 index fa0690f..a780116 100644 --- 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 @@ -2,5 +2,5 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription; import java.time.LocalDate; -public record SubscriptionInfo(Integer subscriptionDurationDesired, LocalDate desiredStartDate) { +public record SubscriptionInfo(Integer desiredSubscriptionDuration, LocalDate desiredStartDate) { } 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 index f5c00ca..a7de3bf 100644 --- 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 @@ -19,11 +19,11 @@ public class SubscriptionConverter { .details(newPaymentMethod.details()) .build(); return Subscription.builder() - .subscriptionDurationDesired(newSubscription.subscriptionDurationDesired()) + .desiredSubscriptionDuration(newSubscription.desiredSubscriptionDuration()) .paymentMethod(paymentMethod) .desiredStartDate(newSubscription.desiredStartDate()) .startDate(newSubscription.desiredStartDate()) - .endDate(newSubscription.desiredStartDate().plusMonths(newSubscription.subscriptionDurationDesired())) + .endDate(newSubscription.desiredStartDate().plusMonths(newSubscription.desiredSubscriptionDuration())) .monthlyAmount(0) .build(); } @@ -32,7 +32,7 @@ public class SubscriptionConverter { return SubscriptionDTO.builder() .subscriptionId(subscription.getSubscriptionId()) .customerId(subscription.getCustomerId()) - .subscriptionDurationDesired(subscription.getSubscriptionDurationDesired()) + .desiredSubscriptionDuration(subscription.getDesiredSubscriptionDuration()) .paymentMethod(subscription.getPaymentMethod()) .desiredStartDate(subscription.getDesiredStartDate()) .startDate(subscription.getStartDate()) 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 index b5e7d32..b802547 100644 --- 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 @@ -12,7 +12,7 @@ public class Subscription { private UUID subscriptionId; private UUID customerId; - private Integer subscriptionDurationDesired; + private Integer desiredSubscriptionDuration; private PaymentMethod paymentMethod; private LocalDate desiredStartDate; private LocalDate startDate; @@ -34,7 +34,7 @@ public class Subscription { } public void setEndDate(){ - this.endDate = this.desiredStartDate.plusMonths(this.subscriptionDurationDesired); + this.endDate = this.desiredStartDate.plusMonths(this.desiredSubscriptionDuration); } public void setDateSubscription(){ 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 index 7dd651f..c03206d 100644 --- 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 @@ -8,7 +8,7 @@ import java.util.Set; public class SubscriptionValidator { - public static final String SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALID = "subscriptionDurationDesired will be 3, 6 or 12 by the ENUM file SubscriptionDurationDesired"; + public static final String SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALID = "desiredSubscriptionDuration will be 3, 6 or 12 by the ENUM file SubscriptionDurationDesired"; public static final String DESIRED_START_DATE_CANNOT_BE_BEFORE_TODAY = "desiredStartDate cannot be before today"; private SubscriptionValidator() { @@ -23,7 +23,7 @@ public class SubscriptionValidator { private static void validateSubscriptionDurationDesired(SubscriptionInfo newSubscription) throws NotValidSubscriptionException { Set VALID_DURATIONS = Set.of(3, 6, 12); - if (!VALID_DURATIONS.contains(newSubscription.subscriptionDurationDesired())) { + if (!VALID_DURATIONS.contains(newSubscription.desiredSubscriptionDuration())) { throw new NotValidSubscriptionException(SUBSCRIPTION_DURATION_DESIRED_IS_NOT_VALID);} } 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 272f09f..5e0952d 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 @@ -26,7 +26,7 @@ public class SubscriptionConverterTest { // Given PaymentMethodInfo paymentMethodInfo = new PaymentMethodInfo(PaymentType.CB.name(), "Maxime Lebreton"); LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); - SubscriptionInfo subscriptionInfo = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + SubscriptionInfo subscriptionInfo = new SubscriptionInfo(DesiredSubscriptionDuration.THREE.getValue(), desiredStartDate); LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); // When @@ -34,7 +34,7 @@ public class SubscriptionConverterTest { // Then assertNotNull(result); - assertEquals(subscriptionInfo.subscriptionDurationDesired(), result.getSubscriptionDurationDesired()); + assertEquals(subscriptionInfo.desiredSubscriptionDuration(), result.getDesiredSubscriptionDuration()); assertEquals(paymentMethodInfo.paymentType(), result.getPaymentMethod().getPaymentType()); assertEquals(paymentMethodInfo.details(), result.getPaymentMethod().getDetails()); assertEquals(subscriptionInfo.desiredStartDate(), result.getDesiredStartDate()); @@ -60,7 +60,7 @@ public class SubscriptionConverterTest { Subscription subscription = Subscription.builder() .subscriptionId(UUID.randomUUID()) .customerId(UUID.randomUUID()) - .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) .paymentMethod(paymentMethod) .desiredStartDate(desiredStartDate) .startDate(desiredStartDate) @@ -73,7 +73,7 @@ public class SubscriptionConverterTest { assertNotNull(result); assertEquals(subscription.getSubscriptionId(), result.getSubscriptionId()); assertEquals(subscription.getCustomerId(), result.getCustomerId()); - assertEquals(subscription.getSubscriptionDurationDesired(), result.getSubscriptionDurationDesired()); + assertEquals(subscription.getDesiredSubscriptionDuration(), result.getDesiredSubscriptionDuration()); assertEquals(subscription.getPaymentMethod().getPaymentType(), result.getPaymentMethod().getPaymentType()); assertEquals(subscription.getPaymentMethod().getDetails(), result.getPaymentMethod().getDetails()); assertEquals(subscription.getDesiredStartDate(), result.getDesiredStartDate()); @@ -95,7 +95,7 @@ public class SubscriptionConverterTest { Subscription subscription = Subscription.builder() .subscriptionId(UUID.randomUUID()) .customerId(UUID.randomUUID()) - .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) .paymentMethod(paymentMethod) .desiredStartDate(desiredStartDate) .startDate(desiredStartDate) @@ -115,7 +115,7 @@ public class SubscriptionConverterTest { void shouldPreserveEmptyStrings() { PaymentMethodInfo paymentMethodInfo = new PaymentMethodInfo(PaymentType.CB.name(), ""); LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); - SubscriptionInfo subscriptionInfo = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + SubscriptionInfo subscriptionInfo = new SubscriptionInfo(DesiredSubscriptionDuration.THREE.getValue(), desiredStartDate); Subscription domainResult = SubscriptionConverter.toDomain(subscriptionInfo, paymentMethodInfo); SubscriptionDTO dtoResult = SubscriptionConverter.toDTO(domainResult); 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 772f62b..98a4678 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 @@ -1,7 +1,7 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDurationDesired; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.DesiredSubscriptionDuration; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -18,7 +18,7 @@ public class SubscriptionTest { void testSubscriptionBuilder() { UUID subscriptionId = UUID.randomUUID(); UUID customerId = UUID.randomUUID(); - Integer subscriptionDurationDesired = SubscriptionDurationDesired.THREE.getValue(); + Integer desiredSubscriptionDuration = DesiredSubscriptionDuration.THREE.getValue(); String paymentType = PaymentType.CB.name(); Object details = new Object(); details = "Maxime Lebreton"; @@ -34,7 +34,7 @@ public class SubscriptionTest { Subscription subscription = Subscription.builder() .subscriptionId(subscriptionId) .customerId(customerId) - .subscriptionDurationDesired(subscriptionDurationDesired) + .desiredSubscriptionDuration(desiredSubscriptionDuration) .paymentMethod(paymentMethod) .desiredStartDate(desiredStartDate) .startDate(startDate) @@ -44,7 +44,7 @@ public class SubscriptionTest { assertEquals(subscriptionId, subscription.getSubscriptionId()); assertEquals(customerId, subscription.getCustomerId()); - assertEquals(subscriptionDurationDesired, subscription.getSubscriptionDurationDesired()); + assertEquals(desiredSubscriptionDuration, subscription.getDesiredSubscriptionDuration()); assertEquals(paymentType, paymentMethod.getPaymentType()); assertEquals(details, paymentMethod.getDetails()); assertEquals(desiredStartDate, subscription.getDesiredStartDate()); @@ -92,12 +92,12 @@ public class SubscriptionTest { } @Test - @DisplayName("setEndDate should instantiate EndDate as the same value as the variable desiredStartDate + subscriptionDurationDesired") + @DisplayName("setEndDate should instantiate EndDate as the same value as the variable desiredStartDate + desiredSubscriptionDuration") void testSetEndDate() { LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); Subscription subscription = Subscription.builder() - .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) .desiredStartDate(desiredStartDate) .build(); @@ -113,7 +113,7 @@ public class SubscriptionTest { LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); LocalDate estimateEndDate = LocalDate.of(2026, 9, 24); Subscription subscription = Subscription.builder() - .subscriptionDurationDesired(SubscriptionDurationDesired.THREE.getValue()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) .desiredStartDate(desiredStartDate) .build(); diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java index a04d067..eebaaf5 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionExceptionTest.java @@ -23,7 +23,7 @@ public class NotValidSubscriptionExceptionTest { @ParameterizedTest @ValueSource(strings = { - "subscriptionDurationDesired will be 3, 6 or 12 by the ENUM file SubscriptionDurationDesired", + "desiredSubscriptionDuration will be 3, 6 or 12 by the ENUM file SubscriptionDurationDesired", "desiredStartDate cannot be before today" }) @DisplayName("Exception should handle different validation messages") 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 f5e0c91..e062047 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,6 +1,6 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDurationDesired; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.DesiredSubscriptionDuration; 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; @@ -21,7 +21,7 @@ public class SubscriptionValidatorTest { @DisplayName("Should validate subscription with valid data") void testValidateValidSubscription() { LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); - SubscriptionInfo validSubscription = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + SubscriptionInfo validSubscription = new SubscriptionInfo(DesiredSubscriptionDuration.THREE.getValue(), desiredStartDate); assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); } @@ -31,9 +31,9 @@ public class SubscriptionValidatorTest { class SubscriptionDurationDesiredValidationTests { @ParameterizedTest - @EnumSource(value = SubscriptionDurationDesired.class) - void testValidateSubscriptionDurationDesired(SubscriptionDurationDesired subscriptionDurationDesired) { - Integer validSubscriptionDurationDesired = subscriptionDurationDesired.getValue(); + @EnumSource(value = DesiredSubscriptionDuration.class) + void testValidateSubscriptionDurationDesired(DesiredSubscriptionDuration desiredSubscriptionDuration) { + Integer validSubscriptionDurationDesired = desiredSubscriptionDuration.getValue(); LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); SubscriptionInfo validSubscription = new SubscriptionInfo(validSubscriptionDurationDesired, desiredStartDate); @@ -41,7 +41,7 @@ public class SubscriptionValidatorTest { } @Test - @DisplayName("Should throw exception when subscriptionDurationDesired is not 3, 6 or 12") + @DisplayName("Should throw exception when desiredSubscriptionDuration is not 3, 6 or 12") void testNotValidateSubscriptionDurationDesired() { Integer notValidSubscriptionDurationDesired = 1 ; LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); @@ -63,7 +63,7 @@ public class SubscriptionValidatorTest { @DisplayName("Should validate when desiredStartDate is before today") void testValidateDesiredStartDate() { LocalDate desiredStartDate = LocalDate.now(); - SubscriptionInfo validSubscription = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + SubscriptionInfo validSubscription = new SubscriptionInfo(DesiredSubscriptionDuration.THREE.getValue(), desiredStartDate); assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription)); } @@ -72,7 +72,7 @@ public class SubscriptionValidatorTest { @DisplayName("Should throw exception when desiredStartDate is before today") void testNotValidateDesiredStartDate() { LocalDate desiredStartDate = LocalDate.of(2026, 3, 24); - SubscriptionInfo validSubscription = new SubscriptionInfo(SubscriptionDurationDesired.THREE.getValue(), desiredStartDate); + SubscriptionInfo validSubscription = new SubscriptionInfo(DesiredSubscriptionDuration.THREE.getValue(), desiredStartDate); NotValidSubscriptionException exception = assertThrows( NotValidSubscriptionException.class, -- 2.54.0 From 655fad8fb2a9193ed0038e5768dd51876cc0e1b2 Mon Sep 17 00:00:00 2001 From: felix-vi Date: Sun, 14 Jun 2026 14:25:47 +0200 Subject: [PATCH 08/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20cr=C3=A9ation=20?= =?UTF-8?q?de=20tests=20pour=20le=20repository?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../SubscriptionRepositoryTest.java | 300 ++++++++++++++++++ 1 file changed, 300 insertions(+) create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java new file mode 100644 index 0000000..ef3735f --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java @@ -0,0 +1,300 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.DesiredSubscriptionDuration; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.time.LocalDate; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class SubscriptionRepositoryTest { + + private SubscriptionRepository repository; + private PaymentMethod paymentMethod; + private Subscription subscription1; + private Subscription subscription2; + private Subscription subscription3; + + @BeforeEach + void setUp() { + repository = new SubscriptionRepository(); + + paymentMethod = PaymentMethod.builder() + .paymentType(PaymentType.CB.name()) + .details("Maxime Lebreton") + .build(); + + LocalDate desiredStartDate1 = LocalDate.of(2026, 6, 24); + subscription1 = Subscription.builder() + .customerId(UUID.randomUUID()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate1) + .monthlyAmount(12.03) + .build(); + subscription1.setRandomSubscriptionUUID(); + subscription1.setDateSubscription(); + + UUID customCustomerId = UUID.randomUUID(); + + LocalDate desiredStartDate2 = LocalDate.of(2026, 7, 24); + subscription2 = Subscription.builder() + .customerId(customCustomerId) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.SIX.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate2) + .monthlyAmount(20) + .build(); + subscription2.setRandomSubscriptionUUID(); + subscription2.setDateSubscription(); + + LocalDate desiredStartDate3 = LocalDate.of(2026, 8, 24); + subscription3 = Subscription.builder() + .customerId(customCustomerId) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.TWELVE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate3) + .monthlyAmount(30) + .build(); + subscription3.setRandomSubscriptionUUID(); + subscription3.setDateSubscription(); + } + + @Test + @DisplayName("New subecription should be empty") + void testNewRepositoryIsEmpty() { + List subscriptions = repository.findAll(); + + assertTrue(subscriptions.isEmpty()); + assertEquals(0, subscriptions.size()); + } + + @Nested + @DisplayName("Save operations") + class SaveOperations { + + @Test + @DisplayName("Save should add a new customer") + void testSaveNewSubscription() { + Subscription savedSubscription = repository.save(subscription1); + + assertEquals(1, repository.findAll().size()); + assertEquals(subscription1.getSubscriptionId(), savedSubscription.getSubscriptionId()); + assertEquals(subscription1.getMonthlyAmount(), savedSubscription.getMonthlyAmount()); + } + + @Test + @DisplayName("Save should update existing subscription with same ID") + void testSaveUpdatesExistingSubscription() { + repository.save(subscription1); + + UUID subscriptionId = subscription1.getSubscriptionId(); + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + Subscription updatedSubscription = Subscription.builder() + .subscriptionId(subscriptionId) + .customerId(UUID.randomUUID()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.SIX.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .monthlyAmount(20) + .build(); + + Subscription savedCustomer = repository.save(updatedSubscription); + + assertEquals(1, repository.findAll().size()); + assertEquals(subscriptionId, savedCustomer.getSubscriptionId()); + assertEquals(6, savedCustomer.getDesiredSubscriptionDuration()); + assertEquals(20, savedCustomer.getMonthlyAmount()); + } + + @Test + @DisplayName("Save multiple subscriptions should add all of them") + void testSaveMultipleSubscriptions() { + repository.save(subscription1); + repository.save(subscription2); + + List subscriptions = repository.findAll(); + + assertEquals(2, subscriptions.size()); + assertTrue(subscriptions.contains(subscription1)); + assertTrue(subscriptions.contains(subscription2)); + } + } + + @Nested + @DisplayName("Find operations") + class FindOperations { + + @BeforeEach + void setUpSubscriptions() { + repository.save(subscription1); + repository.save(subscription2); + repository.save(subscription3); + } + + @Test + @DisplayName("FindAll should return all subscriptions") + void testFindAll() { + List subscriptions = repository.findAll(); + + assertEquals(2, subscriptions.size()); + assertTrue(subscriptions.contains(subscription1)); + assertTrue(subscriptions.contains(subscription2)); + } + + @Test + @DisplayName("FindBySubscriptionId should return subscription with matching ID") + void testFindBySubscriptionId() { + Optional foundSubscription = repository.FindBySubscriptionId(subscription1.getSubscriptionId()); + + assertTrue(foundSubscription.isPresent()); + assertEquals(subscription1.getStartDate(), foundSubscription.get().getStartDate()); + assertEquals(subscription1.getMonthlyAmount(), foundSubscription.get().getMonthlyAmount()); + } + + @Test + @DisplayName("FindBySubscriptionId should return empty Optional when ID doesn't exist") + void testFindBySubscriptionIdNotFound() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + + Optional foundSubscription = repository.FindBySubscriptionId(nonExistentSubscriptionId); + + assertTrue(foundSubscription.isEmpty()); + } + + @Test + @DisplayName("FindByCustomerId should return subscription with matching ID") + void testFindByCustomerId() { + List foundSubscriptions = repository.FindByCustomerId(subscription2.getCustomerId()); + + assertFalse(foundSubscriptions.isEmpty()); + assertTrue(foundSubscriptions.contains(subscription2)); + assertTrue(foundSubscriptions.contains(subscription3)); + } + + @Test + @DisplayName("FindByCustomerId should return empty Optional when ID doesn't exist") + void testFindByCustomerIdNotFound() { + UUID nonExistentCustomerId = UUID.randomUUID(); + + List foundSubscription = repository.FindByCustomerId(nonExistentCustomerId); + + assertTrue(foundSubscription.isEmpty()); + } + + @Test + @DisplayName("ExistsBySubscriptionId should return true when ID exists") + void testExistsBySubscriptionIdExists() { + boolean exists = repository.existsBySubscriptionId(subscription1.getSubscriptionId()); + + assertTrue(exists); + } + + @Test + @DisplayName("ExistsBySubscriptionId should return false when ID doesn't exist") + void testExistsBySubscriptionIdNotExists() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + + boolean exists = repository.existsBySubscriptionId(nonExistentSubscriptionId); + + assertFalse(exists); + } + + @Test + @DisplayName("ExistsByCustomerId should return true when ID exists") + void testExistsByCustomerIdExists() { + boolean exists = repository.existsByCustomerId(subscription1.getCustomerId()); + + assertTrue(exists); + } + + @Test + @DisplayName("ExistsByCustomerId should return false when ID doesn't exist") + void testExistsByCustomerIdNotExists() { + UUID nonExistentCustomerId = UUID.randomUUID(); + + boolean exists = repository.existsByCustomerId(nonExistentCustomerId); + + assertFalse(exists); + } + } + + @Nested + @DisplayName("Delete operations") + class DeleteOperations { + + @BeforeEach + void setUpSubscriptions() { + repository.save(subscription1); + repository.save(subscription2); + repository.save(subscription3); + } + + @Test + @DisplayName("Delete should remove the specified subscription") + void testDelete() { + repository.delete(subscription1); + + List subscriptions = repository.findAll(); + + assertEquals(2, subscriptions.size()); + assertFalse(subscriptions.contains(subscription1)); + assertTrue(subscriptions.contains(subscription2)); + assertTrue(subscriptions.contains(subscription3)); + } + + @Test + @DisplayName("DeleteAll should remove all subscriptions of a customer") + void testDeleteAll() { + repository.deleteByCustomerId(subscription2.getCustomerId()); + + List subscriptions = repository.findAll(); + + assertEquals(1, subscriptions.size()); + assertTrue(subscriptions.contains(subscription1)); + } + + @Test + @DisplayName("DeleteAll should remove all subscriptions") + void testDeleteAll() { + repository.deleteAll(); + + List subscriptions = repository.findAll(); + + assertTrue(subscriptions.isEmpty()); + assertEquals(0, subscriptions.size()); + } + + @Test + @DisplayName("Delete should not throw exception when customer doesn't exist") + void testDeleteNonExistentCustomer() { + LocalDate desiredStartDate = LocalDate.of(2026, 6, 24); + Subscription nonExistentsubscription = Subscription.builder() + .customerId(UUID.randomUUID()) + .desiredSubscriptionDuration(DesiredSubscriptionDuration.THREE.getValue()) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .monthlyAmount(12.03) + .build(); + nonExistentsubscription.setRandomSubscriptionUUID(); + nonExistentsubscription.setDateSubscription(); + + assertDoesNotThrow(() -> repository.delete(nonExistentsubscription)); + + assertEquals(3, repository.findAll().size()); + } + } +} -- 2.54.0 From 3deb17a4c7d114efbec664de0e758024631f5ed7 Mon Sep 17 00:00:00 2001 From: felix-vi Date: Sun, 14 Jun 2026 14:38:27 +0200 Subject: [PATCH 09/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20r=C3=A9ussite=20?= =?UTF-8?q?des=20tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../subscription/SubscriptionRepository.java | 62 +++++++++++++++++++ .../SubscriptionRepositoryTest.java | 11 ++-- 2 files changed, 68 insertions(+), 5 deletions(-) create mode 100644 src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java new file mode 100644 index 0000000..ddd126a --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java @@ -0,0 +1,62 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription; + +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; + +public class SubscriptionRepository { + + private final List subscriptions = new ArrayList<>(); + + public List findAll() { + + return subscriptions; + } + + public void deleteAll() { + + subscriptions.clear(); + } + + public Subscription save(Subscription newSubscription) { + Optional optionalSubscriptionWithSameSubscriptionId = this.findBySubscriptionId(newSubscription.getSubscriptionId()); + optionalSubscriptionWithSameSubscriptionId.ifPresent(subscriptions::remove); + this.subscriptions.add(newSubscription); + return newSubscription; + } + + public List FindByCustomerId(UUID customerUUID) { + return this.subscriptions.stream() + .filter(subscription -> subscription.getCustomerId().equals(customerUUID)) + .toList(); + } + + public Optional findBySubscriptionId(UUID subscriptionUUID) { + return this.subscriptions.stream() + .filter(subscription -> subscription.getSubscriptionId().equals(subscriptionUUID)) + .findFirst(); + } + + public boolean existsByCustomerId(UUID customerUUID) { + return this.subscriptions.stream() + .anyMatch(review -> review.getCustomerId().equals(customerUUID)); + } + + public boolean existsBySubscriptionId(UUID subscriptionUUID) { + return this.subscriptions.stream() + .anyMatch(subscription -> subscription.getSubscriptionId().equals(subscriptionUUID)); + } + + public void deleteByCustomerId(UUID customerUUID) { + + this.subscriptions.removeIf(subscription -> subscription.getCustomerId().equals(customerUUID)); + } + + public void delete(Subscription subscription) { + + this.subscriptions.remove(subscription); + } +} 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 ef3735f..3904bcc 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,8 +1,8 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository; -import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.DesiredSubscriptionDuration; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionRepository; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; import org.junit.jupiter.api.BeforeEach; @@ -150,15 +150,16 @@ public class SubscriptionRepositoryTest { void testFindAll() { List subscriptions = repository.findAll(); - assertEquals(2, subscriptions.size()); + assertEquals(3, subscriptions.size()); assertTrue(subscriptions.contains(subscription1)); assertTrue(subscriptions.contains(subscription2)); + assertTrue(subscriptions.contains(subscription3)); } @Test @DisplayName("FindBySubscriptionId should return subscription with matching ID") void testFindBySubscriptionId() { - Optional foundSubscription = repository.FindBySubscriptionId(subscription1.getSubscriptionId()); + Optional foundSubscription = repository.findBySubscriptionId(subscription1.getSubscriptionId()); assertTrue(foundSubscription.isPresent()); assertEquals(subscription1.getStartDate(), foundSubscription.get().getStartDate()); @@ -170,7 +171,7 @@ public class SubscriptionRepositoryTest { void testFindBySubscriptionIdNotFound() { UUID nonExistentSubscriptionId = UUID.randomUUID(); - Optional foundSubscription = repository.FindBySubscriptionId(nonExistentSubscriptionId); + Optional foundSubscription = repository.findBySubscriptionId(nonExistentSubscriptionId); assertTrue(foundSubscription.isEmpty()); } @@ -258,7 +259,7 @@ public class SubscriptionRepositoryTest { @Test @DisplayName("DeleteAll should remove all subscriptions of a customer") - void testDeleteAll() { + void testDeleteAllSubscriptionOfACustomer() { repository.deleteByCustomerId(subscription2.getCustomerId()); List subscriptions = repository.findAll(); -- 2.54.0 From 49ddb77fb20dade47d02ccc60cfb01ec966bb31f Mon Sep 17 00:00:00 2001 From: felix-vi Date: Sun, 14 Jun 2026 15:32:43 +0200 Subject: [PATCH 10/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20cr=C3=A9ationd?= =?UTF-8?q?=20des=20tests=20et=20d=C3=A9placement=20d'un=20fichier=20qui?= =?UTF-8?q?=20=C3=A9tait=20au=20mauvais=20endroit?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../SubscriptionRepository.java | 2 +- .../SubscriptionNotFoundExceptionTest.java | 74 +++++ .../SubscriptionRepositoryTest.java | 1 - .../usecase/SubscriptionUseCaseTest.java | 269 ++++++++++++++++++ 4 files changed, 344 insertions(+), 2 deletions(-) rename src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/{ => repository}/SubscriptionRepository.java (96%) create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java create mode 100644 src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java similarity index 96% rename from src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java rename to src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java index ddd126a..d3c16c5 100644 --- a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionRepository.java +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java @@ -1,4 +1,4 @@ -package fr.iut_fbleau.but3.dev62.mylibrary.subscription; +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java new file mode 100644 index 0000000..566d811 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java @@ -0,0 +1,74 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class SubscriptionNotFoundExceptionTest { + + @Test + @DisplayName("Exception message should contain the UUID provided for customer") + void testExceptionMessageContainsUUIDForCustomer() { + UUID customerUUID = UUID.randomUUID(); + + SubscriptionNotFoundException exception = new SubscriptionNotFoundException(Optional.of(customerUUID), Optional.empty()); + + String expectedMessage = String.format("The subscriptions with the customer id %s does not exists", customerUUID); + assertEquals(expectedMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception message should contain the UUID provided for subscription") + void testExceptionMessageContainsUUIDForSubscription() { + UUID subscriptionUUID = UUID.randomUUID(); + + SubscriptionNotFoundException exception = new SubscriptionNotFoundException(Optional.empty(), Optional.of(subscriptionUUID)); + + String expectedMessage = String.format("The review with subscription id %s does not exists", subscriptionUUID); + assertEquals(expectedMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should use the correct constant message format for customer") + void testExceptionUsesConstantMessageCustomerFormat() { + UUID customerUUID = UUID.randomUUID(); + + SubscriptionNotFoundException exception = new SubscriptionNotFoundException(Optional.of(customerUUID), Optional.empty()); + + String expectedFormatWithPlaceholder = "The subscriptions with the customer id {0} does not exists"; + assertEquals(SubscriptionNotFoundException.THE_SUBSCRIPTION_WITH_CUSTOMER_ID_DOES_NOT_EXIST_MESSAGE, + expectedFormatWithPlaceholder); + assertTrue(exception.getMessage().contains(customerUUID.toString())); + } + + @Test + @DisplayName("Exception should use the correct constant message format for subscription") + void testExceptionUsesConstantMessageSubscriptionFormat() { + UUID subscriptionUUID = UUID.randomUUID(); + + SubscriptionNotFoundException exception = new SubscriptionNotFoundException(Optional.empty(), Optional.of(subscriptionUUID)); + + String expectedFormatWithPlaceholder = "The subscription with subscription id {0} does not exists"; + assertEquals(SubscriptionNotFoundException.THE_SUBSCRIPTION_WITH_SUBSCRIPTION_ID_DOES_NOT_EXIST_MESSAGE, + expectedFormatWithPlaceholder); + assertTrue(exception.getMessage().contains(subscriptionUUID.toString())); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + UUID subscriptionUUID = UUID.randomUUID(); + + try { + throw new SubscriptionNotFoundException(Optional.empty(), Optional.of(subscriptionUUID)); + } catch (SubscriptionNotFoundException e) { + String expectedMessage = String.format("The subscription with subscription id %s does not exists", subscriptionUUID); + assertEquals(expectedMessage, e.getMessage()); + } + } +} 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 3904bcc..1f3d4fd 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 @@ -2,7 +2,6 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.DesiredSubscriptionDuration; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentType; -import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionRepository; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java new file mode 100644 index 0000000..964ce6e --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java @@ -0,0 +1,269 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase; + +import fr.iut_fbleau.but3.dev62.mylibrary.review.exception.NotValidReviewException; +import fr.iut_fbleau.but3.dev62.mylibrary.review.exception.ReviewNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.*; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; +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 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.time.LocalDate; +import java.util.List; +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.*; +import static org.mockito.Mockito.never; + +@ExtendWith(MockitoExtension.class) +public class SubscriptionUseCaseTest { + + @Mock + private SubscriptionRepository subscriptionRepository; + + @InjectMocks + private SubscriptionUseCase subscriptionUseCase; + + private UUID subscriptionId; + private UUID customerId; + private Integer desiredSubscriptionDuration; + private PaymentMethod paymentMethod; + private LocalDate desiredStartDate; + private double monthlyAmount; + private Subscription testSubscription; + private SubscriptionInfo validSubscriptionInfo; + + @BeforeEach + void setUp() { + subscriptionId = UUID.randomUUID(); + customerId = UUID.randomUUID(); + desiredSubscriptionDuration = DesiredSubscriptionDuration.THREE.getValue(); + desiredStartDate = LocalDate.of(2026, 6, 24); + paymentMethod = PaymentMethod.builder() + .paymentType(PaymentType.CB.name()) + .details("Maxime Lebreton") + .build(); + monthlyAmount = 12.99; + + testSubscription = Subscription.builder() + .subscriptionId(subscriptionId) + .customerId(customerId) + .desiredSubscriptionDuration(desiredSubscriptionDuration) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .monthlyAmount(monthlyAmount) + .build(); + + validSubscriptionInfo = new SubscriptionInfo(desiredSubscriptionDuration, desiredStartDate); + } + + @Nested + @DisplayName("Register subscription tests") + class RegisterSubscriptionTests { + + @Test + @DisplayName("Should register review when valid data is provided") + void testRegisterSubscriptionithValidData() 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 review data is not valid") + void testRegisterSubscriptionWithInvalidData() { + SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo(0, desiredStartDate); + + assertThrows(NotValidSubscriptionException.class, + () -> subscriptionUseCase.registerSubscription(invalidSubscriptionInfo)); + + verify(subscriptionRepository, never()).save(any(Subscription.class)); + } + } + + @Nested + @DisplayName("Find subscription tests") + class FindSubscriptionTests { + + @Test + @DisplayName("Should return reviews when customer ID exists") + void testFindSubscriptionByCustomerId() { + when(subscriptionRepository.FindByCustomerId(customerId)).thenReturn(List.of(testSubscription)); + + List foundSubscriptions = subscriptionUseCase.findReviewByCustomerId(customerId); + + assertFalse(foundSubscriptions.isEmpty()); + boolean allSameCustomer = foundSubscriptions.stream() + .allMatch(review -> review.getCustomerId().equals(customerId)); + assertTrue(allSameCustomer); + verify(subscriptionRepository, times(1)).FindByCustomerId(customerId); + } + + @Test + @DisplayName("Should return empty Optional when customer ID doesn't exist") + void testFindSubscriptionByCustomerIdNotFound() { + UUID nonExistentCustomerId = UUID.randomUUID(); + when(subscriptionRepository.FindByCustomerId(nonExistentCustomerId)).thenReturn(List.of()); + + List foundSubscriptions = subscriptionUseCase.findReviewByCustomerId(nonExistentCustomerId); + + assertTrue(foundSubscriptions.isEmpty()); + verify(subscriptionRepository, times(1)).FindByCustomerId(nonExistentCustomerId); + } + + @Test + @DisplayName("Should return review when Subscription ID exists") + void testFindSubscriptionBySubscriptionId() { + when(subscriptionRepository.findBySubscriptionId(subscriptionId)).thenReturn(Optional.of(testSubscription)); + + Optional foundSubscription = subscriptionUseCase.findReviewBySubscriptionId(subscriptionId); + + assertTrue(foundSubscription.isPresent()); + assertEquals(testSubscription.getCustomerId(), foundSubscription.get().getCustomerId()); + assertEquals(testSubscription.getMonthlyAmount(), foundSubscription.get().getMonthlyAmount()); + verify(subscriptionRepository, times(1)).findBySubscriptionId(subscriptionId); + } + + @Test + @DisplayName("Should return empty Optional when review ID doesn't exist") + void testFindSubscriptionBySubscriptionIdNotFound() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + when(subscriptionRepository.findBySubscriptionId(nonExistentSubscriptionId)).thenReturn(Optional.empty()); + + Optional foundSubscription = subscriptionUseCase.findSubscriptionByReviewId(nonExistentSubscriptionId); + + assertTrue(foundSubscription.isEmpty()); + verify(subscriptionRepository, times(1)).findBySubscriptionId(nonExistentSubscriptionId); + } + } + + @Nested + @DisplayName("Update subscription tests") + class UpdateSubscriptionTests { + + @Test + @DisplayName("Should update subscription when valid data is provided") + void testUpdateSubscriptionWithValidData() throws SubscriptionNotFoundException, NotValidReviewException { + when(subscriptionRepository.findBySubscriptionId(subscriptionId)).thenReturn(Optional.of(testSubscription)); + + LocalDate updateDdesiredStartDate = LocalDate.of(2026, 6, 24); + Subscription updatedSubscription = Subscription.builder() + .subscriptionId(subscriptionId) + .customerId(customerId) + .desiredSubscriptionDuration(desiredSubscriptionDuration) + .paymentMethod(paymentMethod) + .desiredStartDate(desiredStartDate) + .monthlyAmount(monthlyAmount) + .build(); + + when(subscriptionRepository.save(any(Subscription.class))).thenReturn(updatedSubscription); + + SubscriptionInfo updateInfo = new SubscriptionInfo(DesiredSubscriptionDuration.SIX.getValue(), updateDdesiredStartDate); + + SubscriptionDTO result = subscriptionUseCase.updateSubscription(subscriptionId, updateInfo, paymentMethod); + + assertNotNull(result); + assertEquals(customerId, result.getCustomerId()); + assertEquals(monthlyAmount, result.getMonthlyAmount()); + verify(subscriptionRepository, times(1)).findBySubscriptionId(subscriptionId); + verify(subscriptionRepository, times(1)).save(any(Subscription.class)); + } + + @Test + @DisplayName("Should throw exception when subscription ID doesn't exist") + void testUpdateSubscriptionNotFound() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + when(subscriptionRepository.findBySubscriptionId(nonExistentSubscriptionId)).thenReturn(Optional.empty()); + + SubscriptionInfo updateInfo = new SubscriptionInfo(desiredSubscriptionDuration, desiredStartDate); + + assertThrows(SubscriptionNotFoundException.class, + () -> subscriptionUseCase.updateSubscription(nonExistentSubscriptionId, updateInfo, paymentMethod)); + + verify(subscriptionRepository, times(1)).findBySubscriptionId(nonExistentSubscriptionId); + verify(subscriptionRepository, never()).save(any(Subscription.class)); + } + + @Test + @DisplayName("Should throw exception when update data is not valid") + void testUpdateSubscriptionWithInvalidData() { + SubscriptionInfo invalidUpdateInfo = new SubscriptionInfo(0, desiredStartDate); + + assertThrows(NotValidSubscriptionException.class, + () -> subscriptionUseCase.updateSubscription(subscriptionId, invalidUpdateInfo, paymentMethod)); + + verify(subscriptionRepository, never()).findBySubscriptionId(any(UUID.class)); + verify(subscriptionRepository, never()).save(any(Subscription.class)); + } + } + + @Nested + @DisplayName("Delete subscription tests") + class DeleteReviewTests { + + @Test + @DisplayName("Should delete subscriptions when customer ID exists") + void testDeleteSubscriptionsOfACustomer() throws SubscriptionNotFoundException { + when(subscriptionRepository.FindByCustomerId(customerId)).thenReturn(List.of(testSubscription)); + doNothing().when(subscriptionRepository).delete(testSubscription); + + subscriptionUseCase.deleteSubscriptionsOfACustomer(customerId); + + verify(subscriptionRepository, times(1)).FindByCustomerId(customerId); + verify(subscriptionRepository, times(1)).delete(testSubscription); + } + + @Test + @DisplayName("Should throw exception when customer ID doesn't exist") + void testDeleteSubscriptionsOfACustomerNotFound() { + UUID nonExistentCustomerId = UUID.randomUUID(); + when(subscriptionRepository.FindByCustomerId(nonExistentCustomerId)).thenReturn(List.of()); + + assertThrows(ReviewNotFoundException.class, + () -> subscriptionUseCase.deleteSubscriptionsOfACustomer(nonExistentCustomerId)); + + verify(subscriptionRepository, times(1)).FindByCustomerId(nonExistentCustomerId); + verify(subscriptionRepository, never()).delete(any(Subscription.class)); + } + + @Test + @DisplayName("Should delete subscription when subscription ID exist") + void testDeleteSubscription() throws SubscriptionNotFoundException { + when(subscriptionRepository.findBySubscriptionId(subscriptionId)).thenReturn(Optional.of(testSubscription)); + doNothing().when(subscriptionRepository).delete(testSubscription); + + subscriptionUseCase.deleteSubscription(subscriptionId); + + verify(subscriptionRepository, times(1)).findBySubscriptionId(subscriptionId); + verify(subscriptionRepository, times(1)).delete(testSubscription); + } + + @Test + @DisplayName("Should throw exception when subscription ID doesn't exist") + void testDeleteSubscriptionNotFound() { + UUID nonExistentSubscriptionId = UUID.randomUUID(); + when(subscriptionRepository.findBySubscriptionId(nonExistentSubscriptionId)).thenReturn(Optional.empty()); + + assertThrows(ReviewNotFoundException.class, + () -> subscriptionUseCase.deleteSubscription(nonExistentSubscriptionId)); + + verify(subscriptionRepository, times(1)).findBySubscriptionId(nonExistentSubscriptionId); + verify(subscriptionRepository, never()).delete(any(Subscription.class)); + } + } +} -- 2.54.0 From 7c2eb19e13e9022b1198d94efd0d5bcfa41b72b4 Mon Sep 17 00:00:00 2001 From: felix-vi Date: Sun, 14 Jun 2026 16:31:03 +0200 Subject: [PATCH 11/11] =?UTF-8?q?:white=5Fcheck=5Fmark:=20r=C3=A9ussite=20?= =?UTF-8?q?des=20test=20fin=20de=20cette=20feature?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../SubscriptionNotFoundException.java | 21 ++++ .../usecase/SubscriptionUseCase.java | 110 ++++++++++++++++++ .../SubscriptionNotFoundExceptionTest.java | 2 +- .../usecase/SubscriptionUseCaseTest.java | 38 +++--- 4 files changed, 153 insertions(+), 18 deletions(-) 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/usecase/SubscriptionUseCase.java 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..4f73c47 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java @@ -0,0 +1,21 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception; + +import java.text.MessageFormat; +import java.util.Optional; +import java.util.UUID; + +public class SubscriptionNotFoundException extends RuntimeException { + public static final String THE_SUBSCRIPTION_WITH_CUSTOMER_ID_DOES_NOT_EXIST_MESSAGE = "The subscriptions with the customer id {0} does not exists"; + public static final String THE_SUBSCRIPTION_WITH_SUBSCRIPTION_ID_DOES_NOT_EXIST_MESSAGE = "The subscription with subscription id {0} does not exists"; + + public SubscriptionNotFoundException(Optional customerUUID, Optional subscriptionUUID) { + super(buildMessage(customerUUID, subscriptionUUID)); + } + + private static String buildMessage(Optional customerUUID, Optional subscriptionUUID) { + if (customerUUID.isPresent()) { + return MessageFormat.format(THE_SUBSCRIPTION_WITH_CUSTOMER_ID_DOES_NOT_EXIST_MESSAGE, customerUUID.get()); + } + return MessageFormat.format(THE_SUBSCRIPTION_WITH_SUBSCRIPTION_ID_DOES_NOT_EXIST_MESSAGE, subscriptionUUID.get()); + } +} 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..9aebcb7 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java @@ -0,0 +1,110 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase; + +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.PaymentMethodInfo; +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.PaymentMethod; +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.exception.SubscriptionNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.PaymentMethodValidator; +import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.SubscriptionValidator; + +import java.util.*; + +public class SubscriptionUseCase { + + private final SubscriptionRepository subscriptionRepository; + + public SubscriptionUseCase(SubscriptionRepository subscriptionRepository) { + + this.subscriptionRepository = subscriptionRepository; + } + + private Map Output(Subscription subscription){ + Map result = new HashMap<>(); + + result.put("subscriptionId", subscription.getSubscriptionId()); + result.put("startDate", subscription.getStartDate()); + result.put("endDate", subscription.getEndDate()); + result.put("monthlyAmount", subscription.getMonthlyAmount()); + + return result; + } + + public Map registerSubscription(SubscriptionInfo newSubscription, PaymentMethodInfo newPaymentMethod) + throws NotValidSubscriptionException { + SubscriptionValidator.validate(newSubscription); + PaymentMethodValidator.validate(newPaymentMethod); + Subscription subscriptionToRegister = SubscriptionConverter.toDomain(newSubscription, newPaymentMethod); + Subscription subscriptionToRegistered = subscriptionRepository.save(subscriptionToRegister); + return Output(subscriptionToRegistered); + } + + public List findSubscriptionByCustomerId(UUID customerId) { + List optionalSubscriptions = subscriptionRepository.FindByCustomerId(customerId); + return optionalSubscriptions.stream() + .map(SubscriptionConverter::toDTO) + .toList(); + } + + public Optional findSubscriptionBySubscriptionId(UUID subscriptionId) { + Optional optionalSubscription = subscriptionRepository.findBySubscriptionId(subscriptionId); + return optionalSubscription.map(SubscriptionConverter::toDTO); + } + + public SubscriptionDTO updateSubscription(UUID SubscriptionUUID, SubscriptionInfo subscriptionInfo, PaymentMethodInfo paymentMethodInfo) + throws SubscriptionNotFoundException, NotValidSubscriptionException { + SubscriptionValidator.validate(subscriptionInfo); + PaymentMethodValidator.validate(paymentMethodInfo); + Subscription subscriptionBySubscriptionUUID = getSubscriptionIfDoesNotExistThrowSubscriptionNotFoundException( + SubscriptionUUID); + PaymentMethod paymentMethod = PaymentMethod.builder() + .paymentType(paymentMethodInfo.paymentType()) + .details(paymentMethodInfo.details()) + .build(); + Subscription subscription = Subscription.builder() + .subscriptionId(SubscriptionUUID) + .customerId(subscriptionBySubscriptionUUID.getCustomerId()) + .desiredSubscriptionDuration(subscriptionInfo.desiredSubscriptionDuration()) + .paymentMethod(paymentMethod) + .desiredStartDate(subscriptionInfo.desiredStartDate()) + .monthlyAmount(subscriptionBySubscriptionUUID.getMonthlyAmount()) + .build(); + subscription.setDateSubscription(); + Subscription updatedSubscription = subscriptionRepository.save(subscription); + return SubscriptionConverter.toDTO(updatedSubscription); + } + + public void deleteSubscription(UUID subscriptionUUID) throws SubscriptionNotFoundException { + Subscription subscriptionToDelete = getSubscriptionIfDoesNotExistThrowSubscriptionNotFoundException(subscriptionUUID); + this.subscriptionRepository.delete(subscriptionToDelete); + } + + public void deleteSubscriptionsOfACustomer(UUID customerUUID) throws SubscriptionNotFoundException { + List subscriptionsToDelete = getSubscriptionByCustomerIdIfDoesNotExistThrowSubscriptionNotFoundException(customerUUID); + for (Subscription subscription : subscriptionsToDelete) { + subscriptionRepository.delete(subscription); + } + } + + private Subscription getSubscriptionIfDoesNotExistThrowSubscriptionNotFoundException(UUID subscriptionUUID) + throws SubscriptionNotFoundException { + Optional optionalSubscriptionBySubscriptionId = subscriptionRepository.findBySubscriptionId(subscriptionUUID); + if (optionalSubscriptionBySubscriptionId.isEmpty()) { + throw new SubscriptionNotFoundException(Optional.empty(),Optional.of(subscriptionUUID)); + } + return optionalSubscriptionBySubscriptionId.get(); + } + + private List getSubscriptionByCustomerIdIfDoesNotExistThrowSubscriptionNotFoundException(UUID customerUUID) + throws SubscriptionNotFoundException { + List optionalSubscriptionBySubscriptionId = subscriptionRepository.FindByCustomerId(customerUUID); + if (optionalSubscriptionBySubscriptionId.isEmpty()) { + throw new SubscriptionNotFoundException(Optional.of(customerUUID),Optional.empty()); + } + return optionalSubscriptionBySubscriptionId; + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java index 566d811..b122ba8 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java @@ -29,7 +29,7 @@ public class SubscriptionNotFoundExceptionTest { SubscriptionNotFoundException exception = new SubscriptionNotFoundException(Optional.empty(), Optional.of(subscriptionUUID)); - String expectedMessage = String.format("The review with subscription id %s does not exists", subscriptionUUID); + String expectedMessage = String.format("The subscription with subscription id %s does not exists", subscriptionUUID); assertEquals(expectedMessage, exception.getMessage()); } diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java index 964ce6e..7fcf5b8 100644 --- a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java @@ -1,11 +1,11 @@ package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase; import fr.iut_fbleau.but3.dev62.mylibrary.review.exception.NotValidReviewException; -import fr.iut_fbleau.but3.dev62.mylibrary.review.exception.ReviewNotFoundException; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.*; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.PaymentMethod; 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.exception.SubscriptionNotFoundException; import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -18,6 +18,7 @@ import org.mockito.junit.jupiter.MockitoExtension; import java.time.LocalDate; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.UUID; @@ -43,6 +44,7 @@ public class SubscriptionUseCaseTest { private double monthlyAmount; private Subscription testSubscription; private SubscriptionInfo validSubscriptionInfo; + private PaymentMethodInfo validPaymentMethodInfo; @BeforeEach void setUp() { @@ -65,6 +67,7 @@ public class SubscriptionUseCaseTest { .monthlyAmount(monthlyAmount) .build(); + validPaymentMethodInfo = new PaymentMethodInfo(PaymentType.PAYPAL.name(),""); validSubscriptionInfo = new SubscriptionInfo(desiredSubscriptionDuration, desiredStartDate); } @@ -77,20 +80,21 @@ public class SubscriptionUseCaseTest { void testRegisterSubscriptionithValidData() throws NotValidSubscriptionException { when(subscriptionRepository.save(any(Subscription.class))).thenReturn(testSubscription); - UUID registeredId = subscriptionUseCase.registerSubscription(validSubscriptionInfo); + Map registeredSubscription = subscriptionUseCase.registerSubscription(validSubscriptionInfo, validPaymentMethodInfo); - assertNotNull(registeredId); - assertEquals(subscriptionId, registeredId); + assertNotNull(registeredSubscription); + assertEquals(subscriptionId, (UUID) registeredSubscription.get("subscriptionId")); verify(subscriptionRepository, times(1)).save(any(Subscription.class)); } @Test @DisplayName("Should throw exception when review data is not valid") void testRegisterSubscriptionWithInvalidData() { + PaymentMethodInfo invalidPaymentMethodInfo = new PaymentMethodInfo("carte",""); SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo(0, desiredStartDate); assertThrows(NotValidSubscriptionException.class, - () -> subscriptionUseCase.registerSubscription(invalidSubscriptionInfo)); + () -> subscriptionUseCase.registerSubscription(invalidSubscriptionInfo, invalidPaymentMethodInfo)); verify(subscriptionRepository, never()).save(any(Subscription.class)); } @@ -105,7 +109,7 @@ public class SubscriptionUseCaseTest { void testFindSubscriptionByCustomerId() { when(subscriptionRepository.FindByCustomerId(customerId)).thenReturn(List.of(testSubscription)); - List foundSubscriptions = subscriptionUseCase.findReviewByCustomerId(customerId); + List foundSubscriptions = subscriptionUseCase.findSubscriptionByCustomerId(customerId); assertFalse(foundSubscriptions.isEmpty()); boolean allSameCustomer = foundSubscriptions.stream() @@ -120,18 +124,18 @@ public class SubscriptionUseCaseTest { UUID nonExistentCustomerId = UUID.randomUUID(); when(subscriptionRepository.FindByCustomerId(nonExistentCustomerId)).thenReturn(List.of()); - List foundSubscriptions = subscriptionUseCase.findReviewByCustomerId(nonExistentCustomerId); + List foundSubscriptions = subscriptionUseCase.findSubscriptionByCustomerId(nonExistentCustomerId); assertTrue(foundSubscriptions.isEmpty()); verify(subscriptionRepository, times(1)).FindByCustomerId(nonExistentCustomerId); } @Test - @DisplayName("Should return review when Subscription ID exists") + @DisplayName("Should return subscription when Subscription ID exists") void testFindSubscriptionBySubscriptionId() { when(subscriptionRepository.findBySubscriptionId(subscriptionId)).thenReturn(Optional.of(testSubscription)); - Optional foundSubscription = subscriptionUseCase.findReviewBySubscriptionId(subscriptionId); + Optional foundSubscription = subscriptionUseCase.findSubscriptionBySubscriptionId(subscriptionId); assertTrue(foundSubscription.isPresent()); assertEquals(testSubscription.getCustomerId(), foundSubscription.get().getCustomerId()); @@ -140,12 +144,12 @@ public class SubscriptionUseCaseTest { } @Test - @DisplayName("Should return empty Optional when review ID doesn't exist") + @DisplayName("Should return empty Optional when subscription ID doesn't exist") void testFindSubscriptionBySubscriptionIdNotFound() { UUID nonExistentSubscriptionId = UUID.randomUUID(); when(subscriptionRepository.findBySubscriptionId(nonExistentSubscriptionId)).thenReturn(Optional.empty()); - Optional foundSubscription = subscriptionUseCase.findSubscriptionByReviewId(nonExistentSubscriptionId); + Optional foundSubscription = subscriptionUseCase.findSubscriptionBySubscriptionId(nonExistentSubscriptionId); assertTrue(foundSubscription.isEmpty()); verify(subscriptionRepository, times(1)).findBySubscriptionId(nonExistentSubscriptionId); @@ -175,7 +179,7 @@ public class SubscriptionUseCaseTest { SubscriptionInfo updateInfo = new SubscriptionInfo(DesiredSubscriptionDuration.SIX.getValue(), updateDdesiredStartDate); - SubscriptionDTO result = subscriptionUseCase.updateSubscription(subscriptionId, updateInfo, paymentMethod); + SubscriptionDTO result = subscriptionUseCase.updateSubscription(subscriptionId, updateInfo, validPaymentMethodInfo); assertNotNull(result); assertEquals(customerId, result.getCustomerId()); @@ -193,7 +197,7 @@ public class SubscriptionUseCaseTest { SubscriptionInfo updateInfo = new SubscriptionInfo(desiredSubscriptionDuration, desiredStartDate); assertThrows(SubscriptionNotFoundException.class, - () -> subscriptionUseCase.updateSubscription(nonExistentSubscriptionId, updateInfo, paymentMethod)); + () -> subscriptionUseCase.updateSubscription(nonExistentSubscriptionId, updateInfo, validPaymentMethodInfo)); verify(subscriptionRepository, times(1)).findBySubscriptionId(nonExistentSubscriptionId); verify(subscriptionRepository, never()).save(any(Subscription.class)); @@ -205,7 +209,7 @@ public class SubscriptionUseCaseTest { SubscriptionInfo invalidUpdateInfo = new SubscriptionInfo(0, desiredStartDate); assertThrows(NotValidSubscriptionException.class, - () -> subscriptionUseCase.updateSubscription(subscriptionId, invalidUpdateInfo, paymentMethod)); + () -> subscriptionUseCase.updateSubscription(subscriptionId, invalidUpdateInfo, validPaymentMethodInfo)); verify(subscriptionRepository, never()).findBySubscriptionId(any(UUID.class)); verify(subscriptionRepository, never()).save(any(Subscription.class)); @@ -214,7 +218,7 @@ public class SubscriptionUseCaseTest { @Nested @DisplayName("Delete subscription tests") - class DeleteReviewTests { + class DeleteSubscriptionTests { @Test @DisplayName("Should delete subscriptions when customer ID exists") @@ -234,7 +238,7 @@ public class SubscriptionUseCaseTest { UUID nonExistentCustomerId = UUID.randomUUID(); when(subscriptionRepository.FindByCustomerId(nonExistentCustomerId)).thenReturn(List.of()); - assertThrows(ReviewNotFoundException.class, + assertThrows(SubscriptionNotFoundException.class, () -> subscriptionUseCase.deleteSubscriptionsOfACustomer(nonExistentCustomerId)); verify(subscriptionRepository, times(1)).FindByCustomerId(nonExistentCustomerId); @@ -259,7 +263,7 @@ public class SubscriptionUseCaseTest { UUID nonExistentSubscriptionId = UUID.randomUUID(); when(subscriptionRepository.findBySubscriptionId(nonExistentSubscriptionId)).thenReturn(Optional.empty()); - assertThrows(ReviewNotFoundException.class, + assertThrows(SubscriptionNotFoundException.class, () -> subscriptionUseCase.deleteSubscription(nonExistentSubscriptionId)); verify(subscriptionRepository, times(1)).findBySubscriptionId(nonExistentSubscriptionId); -- 2.54.0