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

subscription passe !

Browse Source
This commit is contained in:
Come Thuret
2025-06-09 22:52:27 +02:00
parent 0bb4a21c95
commit 8f76a6fbd4
19 changed files with 357 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
.idea/encodings.xml generated Normal file
View File

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

12
.idea/misc.xml generated Normal file
View File

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

4
.idea/vcs.xml generated
View File

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

15
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionDTO.java Normal file
View File

@@ -0,0 +1,15 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription;
import lombok.Builder;
import lombok.Getter;
import java.util.UUID;
@Builder
@Getter
public class SubscriptionDTO {
private final UUID id;
private final UUID customerId;
private final Integer duration;
private final String paymentMethod;
private final String debutDate;
}

7
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/SubscriptionInfo.java Normal file
View File

@@ -0,0 +1,7 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription;
import java.util.UUID;
public record SubscriptionInfo(UUID customerId, Integer duration, String paymentMethod) {
}

31
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverter.java Normal file
View File

@@ -0,0 +1,31 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
public final class SubscriptionConverter {
private SubscriptionConverter() {
}
public static Subscription toDomain(SubscriptionInfo newSubscription) {
return Subscription.builder()
.customerId(newSubscription.customerId())
.duration(newSubscription.duration())
.paymentMethod(newSubscription.paymentMethod())
.build();
}
public static SubscriptionDTO toDTO(Subscription subscription) {
return SubscriptionDTO.builder()
.id(subscription.getId())
.customerId(subscription.getCustomerId())
.duration(subscription.getDuration())
.paymentMethod(subscription.getPaymentMethod())
.debutDate(subscription.getDebutDate())
.build();
}
}

24
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/Subscription.java Normal file
View File

@@ -0,0 +1,24 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity;
import java.util.UUID;
import lombok.Builder;
import lombok.Getter;
import java.time.LocalDate;
@Builder
@Getter
public class Subscription {
private UUID id;
private UUID customerId;
private Integer duration;
private String paymentMethod;
private String debutDate;
public void setRandomUUID() {
this.id = UUID.randomUUID();
}
public void setDebutDate(String debutDate) {
this.debutDate = LocalDate.now().toString();
}
}

8
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/NotValidSubscriptionException.java Normal file
View File

@@ -0,0 +1,8 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception;
public class NotValidSubscriptionException extends Exception {
public NotValidSubscriptionException(String message) {
super(message);
}
}

12
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/exception/SubscriptionNotFoundException.java Normal file
View File

@@ -0,0 +1,12 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception;
import java.text.MessageFormat;
import java.util.UUID;
public class SubscriptionNotFoundException extends Exception {
public static final String THE_SUBSCRIPTION_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The customer with id {0} does not exist";
public SubscriptionNotFoundException(UUID uuid) {
super(MessageFormat.format(THE_SUBSCRIPTION_WITH_ID_DOES_NOT_EXIST_MESSAGE, uuid));
}
}

36
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepository.java Normal file
View File

@@ -0,0 +1,36 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import lombok.NoArgsConstructor;
public class SubscriptionRepository {
private final List<Subscription> subscriptions = new ArrayList<>();
public List<Subscription> findAll() {
return subscriptions;
}
public Subscription save(Subscription newSubscription) {
Optional<Subscription> optionalSubscriptionWithSameId = this.findByCustomerId(newSubscription.getCustomerId());
optionalSubscriptionWithSameId.ifPresentOrElse(subscriptions::remove, newSubscription::setRandomUUID);
this.subscriptions.add(newSubscription);
return newSubscription;
}
public Optional<Subscription> findByCustomerId(UUID uuid) {
return this.subscriptions.stream()
.filter(subscription -> subscription.getCustomerId().equals(uuid))
.findFirst();
}
public boolean existsById(UUID uuid) {
return this.subscriptions.stream()
.anyMatch(subscription -> subscription.getId().equals(uuid));
}
}

45
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscriptionUseCase.java Normal file
View File

@@ -0,0 +1,45 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.converter.SubscriptionConverter;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.SubscriptionNotFoundException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.SubscriptionValidator;
import java.util.Optional;
import java.util.UUID;
public class SubscriptionUseCase {
private final SubscriptionRepository subscriptionRepository;
public SubscriptionUseCase(SubscriptionRepository subscriptionRepository) {
this.subscriptionRepository = subscriptionRepository;
}
public UUID registerSubscription(SubscriptionInfo newSubscription) throws NotValidSubscriptionException {
SubscriptionValidator.validate(newSubscription);
Subscription subscriptionToRegister = SubscriptionConverter.toDomain(newSubscription);
Subscription subscriptionToRegistered = subscriptionRepository.save(subscriptionToRegister);
if (subscriptionToRegistered.getDuration() <= 0) {
throw new NotValidSubscriptionException("Duration must be positive");
}
return subscriptionToRegistered.getId();
}
public Optional<SubscriptionDTO> findSubscriptionByCustomerId(UUID customerId) {
Optional<Subscription> optionalSubscription = subscriptionRepository.findByCustomerId(customerId);
return optionalSubscription.map(SubscriptionConverter::toDTO);
}
private boolean getSubscriptionIfDoesNotExistThrowSubscriptionNotFoundException(UUID uuid)
throws SubscriptionNotFoundException {
if (subscriptionRepository.existsById(uuid)) {
throw new SubscriptionNotFoundException(uuid);
}
return subscriptionRepository.existsById(uuid);
}
}

38
src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidator.java Normal file
View File

@@ -0,0 +1,38 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException;
public class SubscriptionValidator {
public static final String CUSTOMER_ID_CANNOT_BE_NULL = "Customer ID cannot be null";
public static final String DURATION_CANNOT_BE_NULL = "Duration is not valid";
public static final String PAYMENT_METHOD_CANNOT_BE_BLANK = "Payment Method cannot be blank";
private SubscriptionValidator() {
}
public static void validate(SubscriptionInfo newSubscription) throws fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException {
validateDuration(newSubscription);
validatePaymentMethod(newSubscription);
}
private static void validateDuration(SubscriptionInfo newSubscription) throws fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException {
if (newSubscription.duration() == null) {
throw new fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException(DURATION_CANNOT_BE_NULL);
}
}
private static void validatePaymentMethod(SubscriptionInfo newSubscription) throws fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException {
if (newSubscription.paymentMethod().isBlank()) {
throw new NotValidSubscriptionException(PAYMENT_METHOD_CANNOT_BE_BLANK);
}
}
}

67
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/features/subscription/SubscriptionSteps.java
View File

@@ -6,7 +6,13 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.exception.NotValidCustomerException;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.usecase.CustomerUseCase;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase.SubscriptionUseCase;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
import io.cucumber.datatable.DataTable;
@@ -23,8 +29,12 @@ import java.util.UUID;
public class SubscriptionSteps {
private final CustomerRepository customerRepository = new CustomerRepository();
private final SubscriptionRepository subscriptionRepository = new SubscriptionRepository();
private final SubscriptionUseCase subscriptionUseCase = new SubscriptionUseCase(subscriptionRepository);
private NotValidSubscriptionException notValidSubscriptionException;
private final CustomerRepository customerRepository = new CustomerRepository();
private UUID subscriptionRegistration;
private final Map<String, UUID> customerPhoneUUID = new HashMap<>();
@Given("the system has the following customers:")
@@ -53,18 +63,20 @@ public class SubscriptionSteps {
}
@When("I create a new subscription with CB:")
public void iCreateANewSubscriptionWithCB(DataTable dataTable) {
public void iCreateANewSubscriptionWithCB(DataTable dataTable) throws NotValidSubscriptionException {
List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
Map<String, String> customerInfo = rows.getFirst();
// Extract the first row of data
Map<String, String> subscriptionData = rows.getFirst();
SubscriptionInfo newSubscription = new subscriptionInfo(
subscriptionInfo.get("customerId"),
subscriptionInfo.get("duration"),
subscriptionInfo.get("paymentMethod"),
subscriptionInfo.get("debutDate")
// Create a new SubscriptionInfo object with the correct keys
SubscriptionInfo newSubscription = new SubscriptionInfo(
UUID.fromString(subscriptionData.get("customerId")),
Integer.parseInt(subscriptionData.get("duration")),
subscriptionData.get("paymentMethod")
);
// Register the subscription
subscriptionRegistration = subscriptionUseCase.registerSubscription(newSubscription);
}
@@ -74,43 +86,44 @@ public class SubscriptionSteps {
}
@When("I create a new subscription with Paypal:")
public void iCreateANewSubscriptionWithPaypal(DataTable dataTable) {
public void iCreateANewSubscriptionWithPaypal(DataTable dataTable) throws NotValidSubscriptionException {
List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
Map<String, String> customerInfo = rows.getFirst();
// Extract the first row of data
Map<String, String> subscriptionData = rows.getFirst();
SubscriptionInfo newSubscription = new subscriptionInfo(
subscriptionInfo.get("customerId"),
subscriptionInfo.get("duration"),
subscriptionInfo.get("paymentMethod"),
subscriptionInfo.get("debutDate")
// Create a new SubscriptionInfo object with the correct keys
SubscriptionInfo newSubscription = new SubscriptionInfo(
UUID.fromString(subscriptionData.get("customerId")),
Integer.parseInt(subscriptionData.get("duration")),
subscriptionData.get("paymentMethod")
);
// Register the subscription
subscriptionRegistration = subscriptionUseCase.registerSubscription(newSubscription);
}
@When("I try to create a new subscription with the following information:")
public void iTryToCreateANewSubscriptionWithTheFollowingInformation(DataTable dataTable) {
public void iTryToCreateANewSubscriptionWithTheFollowingInformation(DataTable dataTable) throws NotValidSubscriptionException {
List<Map<String, String>> rows = dataTable.asMaps(String.class, String.class);
Map<String, String> customerInfo = rows.getFirst();
Map<String, String> subscriptionData = rows.getFirst();
SubscriptionInfo newSubscription = new subscriptionInfo(
subscriptionInfo.get("customerId"),
subscriptionInfo.get("duration"),
subscriptionInfo.get("paymentMethod"),
subscriptionInfo.get("debutDate")
SubscriptionInfo newSubscription = new SubscriptionInfo(
UUID.fromString(subscriptionData.get("customerId")),
Integer.parseInt(subscriptionData.get("duration")),
subscriptionData.get("paymentMethod")
);
notValidSubscriptionDurationException = assertThrows(NotValidSubscriptionDurationException.class, () -> subscriptionUseCase.registerSubscription(newSubscription));
notValidSubscriptionException = assertThrows(NotValidSubscriptionException.class, () -> subscriptionUseCase.registerSubscription(newSubscription));
}
@Then("the subsription duration creation fails")
public void theSubsriptionDurationCreationFails() assertNotNull(notValidSubscriptionDurationException);{
}
public void theSubsriptionDurationCreationFails() {assertNotNull(notValidSubscriptionException);}
@And("I receive an error for validation subscription message containing {string}")
public void iReceiveAnErrorForValidationSubscriptionMessageContaining(String errorMessage) {
assertEquals(errorMessage, notValidSubscriptionDurationException.getMessage());
assertEquals(errorMessage, notValidSubscriptionException.getMessage());
}
}

22
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/converter/SubscriptionConverterTest.java
View File

@@ -4,9 +4,9 @@ import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.CustomerInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.converter.CustomerConverter;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Subscription;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
import java.util.UUID;
import java.util.concurrent.Flow;
@@ -18,7 +18,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
@DisplayName(SubscriptionConverter Unit Tests)
@DisplayName("SubscriptionConverter Unit Tests")
public class SubscriptionConverterTest {
@Nested
@@ -29,7 +29,7 @@ public class SubscriptionConverterTest {
@DisplayName("Should convert SubscriptionInfo to Subscription domain object")
void shouldConvertSubscriptionInfoToDomain() {
// Given
SubscriptionInfo subscriptionInfo = new SubcriptionInfo("1", "12", "CB", "2025-06-08");
SubscriptionInfo subscriptionInfo = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "CB");
// When
Subscription result = SubscriptionConverter.toDomain(subscriptionInfo);
@@ -39,7 +39,6 @@ public class SubscriptionConverterTest {
assertEquals(subscriptionInfo.customerId(), result.getCustomerId());
assertEquals(subscriptionInfo.duration(), result.getDuration());
assertEquals(subscriptionInfo.paymentMethod(), result.getPaymentMethod());
assertEquals(subscriptionInfo.debutDate(), result.getDebutDate());
}
}
@@ -50,15 +49,17 @@ public class SubscriptionConverterTest {
@Test
@DisplayName("Should convert Subscriber domain object to SubscriberDTO with all fields mapped correctly")
void shouldConvertSubscriptionToDTO() {
UUID id = UUID.randomUUID();
Subscription subscription = Subscription.builder()
.id(UUID.randomUUID())
.customerId(1)
.customerId(id)
.duration(12)
.paymentMethod("CB")
.debutDate("2025-06-08")
.build();
SubscriptionDTO result = SubscriptionConverter.toDTO(customer);
SubscriptionDTO result = SubscriptionConverter.toDTO(subscription);
assertNotNull(result);
assertEquals(subscription.getId(), result.getId());
@@ -73,7 +74,7 @@ public class SubscriptionConverterTest {
void shouldHandleNullValuesGracefully() {
Subscription subscription = Subscription.builder()
.id(UUID.randomUUID())
.customerId(1)
.customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"))
.duration(null)
.paymentMethod("NullTest")
.debutDate("2025-06-08")
@@ -89,15 +90,12 @@ public class SubscriptionConverterTest {
@Test
@DisplayName("Should preserve empty string values during conversion")
void shouldPreserveEmptyStrings() {
SubscriptionInfo subscriptionInfo = new SubscriptionInfo("", "", "", "");
SubscriptionInfo subscriptionInfo = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "");
Subscription domainResult = SubscriptionConverter.toDomain(subscriptionInfo);
SubscriptionDTO dtoResult = SubscriptionConverter.toDTO(domainResult);
assertEquals("", dtoResult.getCustomerId());
assertEquals("", dtoResult.getDuration());
assertEquals("", dtoResult.getPaymentMethod());
assertEquals("", dtoResult.getDebutDate());
}
}
}

2
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/entity/SubscriptionTest.java
View File

@@ -14,7 +14,7 @@ public class SubscriptionTest {
@DisplayName("Builder should create a valid Subscription instance")
void testSubscriptionBuilder() {
UUID id = UUID.randomUUID();
int customerId = 1;
UUID customerId = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
int duration = 12;
String paymentMethod = "CB";
String debutDate = "2025-06-08";

52
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/repository/SubscriptionRepositoryTest.java
View File

@@ -1,7 +1,7 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer;
import fr.iut_fbleau.but3.dev62.mylibrary.customer.repository.CustomerRepository;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
@@ -25,18 +25,16 @@ public class SubscriptionRepositoryTest {
repository = new SubscriptionRepository();
Subscription1 = Subscription.builder()
.customerId(1)
.customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"))
.duration(12)
.paymentMethod("CB")
.debutDate("2025-06-10")
.build();
Subscription1.setRandomUUID();
Subscription2 = Subscription.builder()
.customerId(2)
.customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"))
.duration(24)
.paymentMethod("Paypal")
.debutDate("2025-06-11")
.build();
Subscription2.setRandomUUID();
}
@@ -47,7 +45,7 @@ public class SubscriptionRepositoryTest {
List<Subscription> subscriptions = repository.findAll();
assertTrue(subscriptions.isEmpty());
assertEquals(0, subsciptions.size());
assertEquals(0, subscriptions.size());
}
@Nested
@@ -57,24 +55,24 @@ public class SubscriptionRepositoryTest {
@Test
@DisplayName("Save should add a new subsciption")
void testSaveNewSubscription() {
Subscription savedSubscription = repository.save(subscription1);
Subscription savedSubscription = repository.save(Subscription1);
assertEquals(1, repository.findAll().size());
assertEquals(subscription1.getId(), savedSubscription.getId());
assertEquals(subscription1.getDebutDate(), savedSubscription.getDebutDate());
assertEquals(Subscription1.getId(), savedSubscription.getId());
assertEquals(Subscription1.getDebutDate(), savedSubscription.getDebutDate());
}
@Test
@DisplayName("Save multiple Subscriptions should add all of them")
void testSaveMultipleSubscriptions() {
repository.save(subscription1);
repository.save(subscription2);
repository.save(Subscription1);
repository.save(Subscription2);
List<Subscription> subscriptions = repository.findAll();
assertEquals(2, subscriptions.size());
assertTrue(subscriptions.contains(subscription1));
assertTrue(subscriptions.contains(subscription2));
assertTrue(subscriptions.contains(Subscription1));
assertTrue(subscriptions.contains(Subscription2));
}
}
@@ -84,8 +82,8 @@ public class SubscriptionRepositoryTest {
@BeforeEach
void setUpSubscriptions() {
repository.save(subscription1);
repository.save(subscription2);
repository.save(Subscription1);
repository.save(Subscription2);
}
@Test
@@ -94,18 +92,18 @@ public class SubscriptionRepositoryTest {
List<Subscription> subscriptions = repository.findAll();
assertEquals(2, subscriptions.size());
assertTrue(subscriptions.contains(subscription1));
assertTrue(subscriptions.contains(subscription2));
assertTrue(subscriptions.contains(Subscription1));
assertTrue(subscriptions.contains(Subscription2));
}
@Test
@DisplayName("FindById should return subscriptions with matching ID")
void testFindById() {
Optional<Subsciption> foundSubscription = repository.findById(subscription1.getId());
Optional<Subscription> foundSubscription = repository.findByCustomerId(Subscription1.getId());
assertTrue(foundSubscription.isPresent());
assertEquals(subscription1.getFirstName(), foundSubscription.get().getId());
assertEquals(subscription1.getLastName(), foundSubscription.get().getCustomerId());
assertEquals(Subscription1.getId(), foundSubscription.get().getId());
assertEquals(Subscription1.getCustomerId(), foundSubscription.get().getCustomerId());
}
@Test
@@ -113,7 +111,7 @@ public class SubscriptionRepositoryTest {
void testFindByIdNotFound() {
UUID nonExistentId = UUID.randomUUID();
Optional<Subscription> foundSubscription = repository.findById(nonExistentId);
Optional<Subscription> foundSubscription = repository.findByCustomerId(nonExistentId);
assertTrue(foundSubscription.isEmpty());
}
@@ -121,17 +119,17 @@ public class SubscriptionRepositoryTest {
@Test
@DisplayName("FindByCustomerId should return customer with matching customer id")
void testFindByCustomerId() {
Optional<Subscription> foundSubscription = repository.findByCustomerId("1");
Optional<Subscription> foundSubscription = repository.findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"));
assertTrue(foundSubscription.isPresent());
assertEquals(subscription1.getId(), foundSubscription.get().getId());
assertEquals(subscription1.getDebutDate(), foundSubscription.get().getDebutDate());
assertEquals(Subscription1.getId(), foundSubscription.get().getId());
assertEquals(Subscription1.getDebutDate(), foundSubscription.get().getDebutDate());
}
@Test
@DisplayName("FindByCustomerId should return empty Optional when phone number doesn't exist")
void testFindByPhoneNumberNotFound() {
Optional<Subscription> foundSubscription = repository.findByCustomerId("0");
Optional<Subscription> foundSubscription = repository.findByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000"));
assertTrue(foundSubscription.isEmpty());
}
@@ -139,7 +137,7 @@ public class SubscriptionRepositoryTest {
@Test
@DisplayName("ExistsById should return true when ID exists")
void testExistsByIdExists() {
boolean exists = repository.existsById(subscription1.getId());
boolean exists = repository.existsById(Subscription1.getId());
assertTrue(exists);
}

36
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/usecase/SubscribeUseCaseTest.java
View File

@@ -1,13 +1,12 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.entity.Subscription;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.SubscriptionNotFoundException;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.IllegalSubscriptionPointException;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.exception.NotValidSubscriptionException;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.repository.SubscriptionRepository;
import fr.iut_fbleau.but3.dev62.mylibrary.Subscription.usecase.SubscriptionUseCase;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionDTO;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.entity.Subscription;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.SubscriptionNotFoundException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.repository.SubscriptionRepository;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.usecase.SubscriptionUseCase;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
@@ -42,13 +41,12 @@ public class SubscribeUseCaseTest {
subscriptionId = UUID.randomUUID();
testSubscription = Subscription.builder()
.id(subscriptionId)
.CustomerId(1)
.customerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"))
.duration(12)
.phaymentMethod("CB")
.debutDate("2025-06-10")
.paymentMethod("CB")
.build();
validSubscriptionInfo = new SubscriptionInfo("1", "12", "CB", "2025-06-08");
validSubscriptionInfo = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "CB");
}
@Nested
@@ -70,7 +68,7 @@ public class SubscribeUseCaseTest {
@Test
@DisplayName("Should throw exception when subscription data is not valid")
void testRegisterSubscriptionWithInvalidData() {
SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo("", "", "");
SubscriptionInfo invalidSubscriptionInfo = new SubscriptionInfo(null, null, "");
assertThrows(NotValidSubscriptionException.class,
() -> subscriptionUseCase.registerSubscription(invalidSubscriptionInfo));
@@ -86,25 +84,25 @@ public class SubscribeUseCaseTest {
@Test
@DisplayName("Should return subscription when phone number exists")
void testFindSubscriptionByCustomerId() {
when(subscriptionRepository.findByCustomerId(1)).thenReturn(Optional.of(testSubscription));
when(subscriptionRepository.findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"))).thenReturn(Optional.of(testSubscription));
Optional<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(1);
Optional<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"));
assertTrue(foundSubscription.isPresent());
assertEquals(testSubscription.getId(), foundSubscription.get().getId());
assertEquals(testSubscription.getDebutDate(), foundSubscription.get().getDebutDate());
verify(subscriptionRepository, times(1)).findByCustomerId(1);
verify(subscriptionRepository, times(1)).findByCustomerId(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"));
}
@Test
@DisplayName("Should return empty Optional when phone number doesn't exist")
void testFindSubscriptionByPhoneNumberNotFound() {
when(subscriptionRepository.findByCustomerId(0)).thenReturn(Optional.empty());
when(subscriptionRepository.findByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000"))).thenReturn(Optional.empty());
Optional<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(0);
Optional<SubscriptionDTO> foundSubscription = subscriptionUseCase.findSubscriptionByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000"));
assertTrue(foundSubscription.isEmpty());
verify(subscriptionRepository, times(1)).findByCustomerId(0);
verify(subscriptionRepository, times(1)).findByCustomerId(UUID.fromString("0000000-0000-0000-0000-000000000000"));
}
}

32
src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/subscription/validator/SubscriptionValidatorTest.java
View File

@@ -1,8 +1,5 @@
package fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.validator.SubscriptionValidator;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.SubscriptionInfo;
import fr.iut_fbleau.but3.dev62.mylibrary.subscription.exception.NotValidSubscriptionException;
import org.junit.jupiter.api.DisplayName;
@@ -11,6 +8,8 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.*;
public class SubscriptionValidatorTest {
@@ -18,7 +17,7 @@ public class SubscriptionValidatorTest {
@Test
@DisplayName("Should validate subscription with valid data")
void testValidateValidSubscription() {
SubscriptionInfo validSubscription = new SubscriptionInfo("1", "12", "CB", "2025-06-08");
SubscriptionInfo validSubscription = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "CB");
assertDoesNotThrow(() -> SubscriptionValidator.validate(validSubscription));
}
@@ -30,21 +29,22 @@ public class SubscriptionValidatorTest {
@Test
@DisplayName("Should throw exception when customer id is blank")
void testValidateBlankCustomerId() {
SubscriptionInfo subscriptionWithBlankCustomerId = new SubscriptionInfo("", "12", "CB", "2025-06-08");
SubscriptionInfo subscriptionWithBlankCustomerId = new SubscriptionInfo(null, 12, "CB");
NotValidSubscriptionException exception = assertThrows(
NotValidSubscriptionException.class,
() -> SubscriptionValidator.validate(subscriptionWithBlankCustomerId)
);
assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_BLANK, exception.getMessage());
assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_NULL,
exception.getMessage());
}
@ParameterizedTest
/**@ParameterizedTest
@ValueSource(strings = {" ", " ", "\t", "\n"})
@DisplayName("Should throw exception when customer id contains only whitespace")
void testValidateWhitespaceCustomerId(String whitespace) {
SubscriptionInfo subscriptionWithWhitespaceFirstName = new SubscriptionInfo(whitespace, "12", "CB", "2025-06-08");
SubscriptionInfo subscriptionWithWhitespaceFirstName = new SubscriptionInfo(whitespace, 12, "CB");
NotValidSubscriptionException exception = assertThrows(
NotValidSubscriptionException.class,
@@ -52,7 +52,7 @@ public class SubscriptionValidatorTest {
);
assertEquals(SubscriptionValidator.CUSTOMER_ID_CANNOT_BE_BLANK, exception.getMessage());
}
}**/
}
@Nested
@@ -62,21 +62,21 @@ public class SubscriptionValidatorTest {
@Test
@DisplayName("Should throw exception when duration is blank")
void testValidateBlankDuration() {
SubscriptionInfo subscriptionWithBlankDuration = new SubscriptionInfo("1", "", "CB", "2025-06-08");
SubscriptionInfo subscriptionWithBlankDuration = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), null, "CB");
NotValidSubscriptionException exception = assertThrows(
NotValidSubscriptionException.class,
() -> SubscriptionValidator.validate(subscriptionWithBlankDuration)
);
assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_BLANK, exception.getMessage());
assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_NULL, exception.getMessage());
}
@ParameterizedTest
/**@ParameterizedTest
@ValueSource(strings = {" ", " ", "\t", "\n"})
@DisplayName("Should throw exception when last name contains only whitespace")
void testValidateWhitespaceDuration(String whitespace) {
SubscriptionInfo subscriptionWithWhitespaceDuration = new SubscriptionInfo("1", whitespace, "CB", "2025-06-08");
SubscriptionInfo subscriptionWithWhitespaceDuration = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), whitespace, "CB");
NotValidSubscriptionException exception = assertThrows(
NotValidSubscriptionException.class,
@@ -84,7 +84,7 @@ public class SubscriptionValidatorTest {
);
assertEquals(SubscriptionValidator.DURATION_CANNOT_BE_BLANK, exception.getMessage());
}
}**/
}
@Nested
@@ -94,7 +94,7 @@ public class SubscriptionValidatorTest {
@Test
@DisplayName("Should throw exception when payment method is blank")
void testValidateBlankPaymentMethod() {
SubscriptionInfo subscriptionWithBlankPaymentMethod = new SubscriptionInfo("1", "12", "", "2025-06-08");
SubscriptionInfo subscriptionWithBlankPaymentMethod = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, "");
NotValidSubscriptionException exception = assertThrows(
NotValidSubscriptionException.class,
@@ -108,7 +108,7 @@ public class SubscriptionValidatorTest {
@ValueSource(strings = {" ", " ", "\t", "\n"})
@DisplayName("Should throw exception when payment method contains only whitespace")
void testValidateWhitespacePhoneNumber(String whitespace) {
SubscriptionInfo subscriptionWithWhitespacePhoneNumber = new SubscriptionInfo("1", "12", whitespace, "2025-06-08");
SubscriptionInfo subscriptionWithWhitespacePaymentMethod = new SubscriptionInfo(UUID.fromString("123e4567-e89b-12d3-a456-426614174000"), 12, whitespace);
NotValidSubscriptionException exception = assertThrows(
NotValidSubscriptionException.class,

20
src/test/resources/features/subscription.feature
View File

@@ -3,26 +3,26 @@
Feature: Manage customer subscription
Background:
Given the system has the following customers:
| customerId | firstName | lastNale | phoneNumer | loyaltyPoints |
| 1 | John | Doe | 0612345678 | 100 |
| 2 | Bob | Dupond | 0687654321 | 50 |
| 3 | Alice | Untel | 0698765432 | 0 |
| customerId | firstName | lastName | phoneNumer | pointsFidelite |
| 11111111-1111-1111-1111-111111111111 | John | Doe | 0612345678 | 100 |
| 22222222-2222-2222-2222-222222222222 | Bob | Dupond | 0687654321 | 50 |
| 33333333-3333-3333-3333-333333333333 | Alice | Untel | 0698765432 | 0 |
Scenario: Create a new subscription
When I create a new subscription with CB:
| customerId | duration | paymentMethod | debutDate |
| 1 | 12 | CB | 2025-06-10 |
| customerId | duration | paymentMethod |
| 11111111-1111-1111-1111-111111111111 | 12 | CB |
Then a new subscription is created
Scenario: Create a new subscription
When I create a new subscription with Paypal:
| customerId | duration | paymentMethod | debutDate |
| 2 | 24 | Paypal | 2025-06-11 |
| customerId | duration | paymentMethod |
| 22222222-2222-2222-2222-222222222222 | 24 | Paypal |
Then a new subscription is created
Scenario: Attempt to create a subscription with invalid duration:
When I try to create a new subscription with the following information:
| customerId | duration | paymentMethod | debutDate |
| 3 | 0 | CB | 2025-06-12 |
| customerId | duration | paymentMethod |
| 33333333-3333-3333-3333-333333333333 | 0 | CB |
Then the subsription duration creation fails
And I receive an error for validation subscription message containing "Duration must be positive"