From 7c2eb19e13e9022b1198d94efd0d5bcfa41b72b4 Mon Sep 17 00:00:00 2001 From: felix-vi Date: Sun, 14 Jun 2026 16:31:03 +0200 Subject: [PATCH] =?UTF-8?q?:white=5Fcheck=5Fmark:=20r=C3=A9ussite=20des=20?= =?UTF-8?q?test=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);