lebretonm/Projet_Pierront_Maxime_Marvin_Patrick
1
0
Fork 0
forked from pierront/mylibrary-template
Code Pull Requests Activity

✅ réussite des test fin de cette feature

Browse Source
This commit was merged in pull request #3.
This commit is contained in:
Patrick FELIX-VIMALARATNAM
2026-06-14 16:31:03 +02:00
parent 49ddb77fb2
commit 7c2eb19e13
4 changed files with 153 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java
+21
View File
@@ -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<UUID> customerUUID, Optional<UUID> subscriptionUUID) {
super(buildMessage(customerUUID, subscriptionUUID));
}
private static String buildMessage(Optional<UUID> customerUUID, Optional<UUID> 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());
}
}
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java
+110
View File
@@ -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<String, Object> Output(Subscription subscription){
Map<String, Object> 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<String, Object> 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<SubscriptionDTO> findSubscriptionByCustomerId(UUID customerId) {
List<Subscription> optionalSubscriptions = subscriptionRepository.FindByCustomerId(customerId);
return optionalSubscriptions.stream()
.map(SubscriptionConverter::toDTO)
.toList();
}
public Optional<SubscriptionDTO> findSubscriptionBySubscriptionId(UUID subscriptionId) {
Optional<Subscription> 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<Subscription> subscriptionsToDelete = getSubscriptionByCustomerIdIfDoesNotExistThrowSubscriptionNotFoundException(customerUUID);
for (Subscription subscription : subscriptionsToDelete) {
subscriptionRepository.delete(subscription);
}
}
private Subscription getSubscriptionIfDoesNotExistThrowSubscriptionNotFoundException(UUID subscriptionUUID)
throws SubscriptionNotFoundException {
Optional<Subscription> optionalSubscriptionBySubscriptionId = subscriptionRepository.findBySubscriptionId(subscriptionUUID);
if (optionalSubscriptionBySubscriptionId.isEmpty()) {
throw new SubscriptionNotFoundException(Optional.empty(),Optional.of(subscriptionUUID));
}
return optionalSubscriptionBySubscriptionId.get();
}
private List<Subscription> getSubscriptionByCustomerIdIfDoesNotExistThrowSubscriptionNotFoundException(UUID customerUUID)
throws SubscriptionNotFoundException {
List<Subscription> optionalSubscriptionBySubscriptionId = subscriptionRepository.FindByCustomerId(customerUUID);
if (optionalSubscriptionBySubscriptionId.isEmpty()) {
throw new SubscriptionNotFoundException(Optional.of(customerUUID),Optional.empty());
}
return optionalSubscriptionBySubscriptionId;
}
}
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundExceptionTest.java
+1 -1
View File
@@ -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());
}
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCaseTest.java
+21 -17
View File
@@ -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<String, Object> 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<SubscriptionDTO> foundSubscriptions = subscriptionUseCase.findReviewByCustomerId(customerId);
List<SubscriptionDTO> 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<SubscriptionDTO> foundSubscriptions = subscriptionUseCase.findReviewByCustomerId(nonExistentCustomerId);
List<SubscriptionDTO> 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<SubscriptionDTO> foundSubscription = subscriptionUseCase.findReviewBySubscriptionId(subscriptionId);
Optional<SubscriptionDTO> 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<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByReviewId(nonExistentSubscriptionId);
Optional<SubscriptionDTO> 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);