diff --git a/interface-contracts.json b/interface-contracts.json index c5375c0..5f4bdbc 100644 --- a/interface-contracts.json +++ b/interface-contracts.json @@ -19,6 +19,12 @@ } }, + + + + + + "PasserCommande": { "input": { "clientId": "uuid", @@ -40,6 +46,12 @@ "pointsFideliteGagnes": "integer" } }, + + + + + + "GererAvis": { "input": { "clientId": "uuid", diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/AdresseInfo.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/AdresseInfo.java new file mode 100644 index 0000000..331871c --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/AdresseInfo.java @@ -0,0 +1,3 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande; + +public record AdresseInfo(String rue, String ville, String codePostal, String pays) {} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeDTO.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeDTO.java new file mode 100644 index 0000000..5aad692 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeDTO.java @@ -0,0 +1,23 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande; + +import lombok.Builder; +import lombok.Getter; + +import java.util.List; +import java.util.UUID; + +@Getter +@Builder +public class CommandeDTO { + private UUID clientId; + private List lignesCommande; + private String rue; + private String ville; + private String codePostal; + private String pays; + private String modePaiement; + private UUID commandeId ; + private double montantTotal ; + private Integer pointsFideliteGagnes ; + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeInfo.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeInfo.java new file mode 100644 index 0000000..6d691b0 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/CommandeInfo.java @@ -0,0 +1,6 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande; + +import java.util.List; + +public record CommandeInfo(List listeLigne , String modePayement) { +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeDTO.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeDTO.java new file mode 100644 index 0000000..73626de --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeDTO.java @@ -0,0 +1,15 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande; + + +import lombok.Builder; +import lombok.Getter; + +import java.util.UUID; + +@Getter +@Builder +public class LigneCommandeDTO { + + int quantite; + UUID id; +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeInfo.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeInfo.java new file mode 100644 index 0000000..98256a3 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/LigneCommandeInfo.java @@ -0,0 +1,6 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande; + +import java.util.UUID; + +public record LigneCommandeInfo(int quantite) { +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/ModePaiement.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/ModePaiement.java new file mode 100644 index 0000000..8a2bf36 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/ModePaiement.java @@ -0,0 +1,7 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande; + +public enum ModePaiement { + CB, + PAYPAL, + POINTS_FIDELITE, +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverter.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverter.java new file mode 100644 index 0000000..2d85e37 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverter.java @@ -0,0 +1,59 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; + +public final class CommandeConverter { + + + public static Commande toDomain(CommandeInfo commandeInfo, AdresseInfo adressInfo, String modePaiement) { + return Commande.builder() + .lignesCommande(commandeInfo.listeLigne()) + .rue(adressInfo.rue()) + .ville(adressInfo.ville()) + .codePostal(adressInfo.codePostal()) + .pays(adressInfo.pays()) + .modePaiement(commandeInfo.modePayement()) + .build(); + } + + public static Commande toDomain(CommandeInfo commandeInfo, AdresseInfo adressInfo) { + return Commande.builder() + .lignesCommande(commandeInfo.listeLigne()) + .rue(adressInfo.rue()) + .ville(adressInfo.ville()) + .codePostal(adressInfo.codePostal()) + .pays(adressInfo.pays()) + .modePaiement(commandeInfo.modePayement()) + .build(); + } + + public static CommandeDTO toDTO(CommandeInfo commandeInfo, AdresseInfo adressInfo, String modePaiement) { + return CommandeDTO.builder() + .lignesCommande(commandeInfo.listeLigne()) + .rue(adressInfo.rue()) + .ville(adressInfo.ville()) + .codePostal(adressInfo.codePostal()) + .pays(adressInfo.pays()) + .modePaiement(modePaiement) + .build(); + } + + public static CommandeDTO toDTO(Commande commande) { + return CommandeDTO.builder() + .lignesCommande(commande.getLignesCommande()) + .rue(commande.getRue()) + .ville(commande.getVille()) + .codePostal(commande.getCodePostal()) + .pays(commande.getPays()) + .modePaiement(commande.getModePaiement()) + .commandeId(commande.getCommandeId()) + .clientId(commande.getClientId()) + .montantTotal(commande.getMontantTotal()) + .pointsFideliteGagnes(commande.getPointsFideliteGagnes()) + .build(); + } + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverter.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverter.java new file mode 100644 index 0000000..f7732e3 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverter.java @@ -0,0 +1,22 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.LigneCommande; + +public final class LigneCommandeConverter { + + public static LigneCommande toDomain(LigneCommandeInfo ligneCommandeInfo) { + return LigneCommande.builder() + .quantite(ligneCommandeInfo.quantite()) + .build(); + } + + public static LigneCommandeDTO toDTO(LigneCommandeInfo ligneCommandeInfo) { + return LigneCommandeDTO.builder() + .quantite(ligneCommandeInfo.quantite()) + .build(); + } + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/Commande.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/Commande.java new file mode 100644 index 0000000..16abe85 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/Commande.java @@ -0,0 +1,44 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement; +import lombok.Builder; +import lombok.Getter; + +import java.util.List; +import java.util.UUID; + +@Getter +@Builder +public class Commande { + private UUID clientId; + private List lignesCommande; + private String rue; + private String ville; + private String codePostal; + private String pays; + private String modePaiement; + + private UUID commandeId ; + private double montantTotal ; + private Integer pointsFideliteGagnes ; + + public void setRandomUUID() { + this.clientId = UUID.randomUUID(); + } + + public void setRandomUUIDCommande() { + this.commandeId = UUID.randomUUID(); + } + + public int convertPointsFidelite(){ + if (this.montantTotal==0|| this.montantTotal<=0){ + return 0; + } + return (int) Math.ceil(this.getMontantTotal()); + } + + + // conversion point de fidéliter + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommande.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommande.java new file mode 100644 index 0000000..9b9844c --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommande.java @@ -0,0 +1,20 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity; + + +import lombok.Builder; +import lombok.Getter; + +import java.util.UUID; + +@Getter +@Builder +public class LigneCommande { + + int quantite; + UUID livreId; + + public void setRandomUUID() { + this.livreId = UUID.randomUUID(); + } + +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/CommandeNotFoundException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/CommandeNotFoundException.java new file mode 100644 index 0000000..251706e --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/CommandeNotFoundException.java @@ -0,0 +1,13 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception; + +import java.text.MessageFormat; +import java.util.UUID; + +public class CommandeNotFoundException extends RuntimeException { + + public static final String THE_COMMANDE_WITH_ID_DOES_NOT_EXIST_MESSAGE = "The commande with id {0} does not exist"; + + public CommandeNotFoundException(UUID uuid) { + super(MessageFormat.format(THE_COMMANDE_WITH_ID_DOES_NOT_EXIST_MESSAGE, uuid)); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidAdressException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidAdressException.java new file mode 100644 index 0000000..996a601 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidAdressException.java @@ -0,0 +1,7 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception; + +public class NotValidAdressException extends RuntimeException { + public NotValidAdressException(String message) { + super(message); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidCommandeException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidCommandeException.java new file mode 100644 index 0000000..c7016a1 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidCommandeException.java @@ -0,0 +1,7 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception; + +public class NotValidCommandeException extends RuntimeException { + public NotValidCommandeException(String message) { + super(message); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidLigneCommandeException.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidLigneCommandeException.java new file mode 100644 index 0000000..3a3a656 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/NotValidLigneCommandeException.java @@ -0,0 +1,7 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception; + +public class NotValidLigneCommandeException extends RuntimeException { + public NotValidLigneCommandeException(String message) { + super(message); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepository.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepository.java new file mode 100644 index 0000000..39ad758 --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepository.java @@ -0,0 +1,47 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.repository; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +public class CommandeRepository { + + private final List commande = new ArrayList<>(); + + public List findAll(){return commande;} + + + public void deleteAll() { + commande.clear(); + } + + public Commande save(Commande newCommande){ + Optional optionalCommandeWithSameIsbn = this.findById(newCommande.getCommandeId()); + optionalCommandeWithSameIsbn.ifPresent(commande::remove); + this.commande.add(newCommande); + return newCommande; + } + + public Optional findById(UUID uuid){ + return this.commande.stream() + .filter(customer -> customer.getCommandeId().equals(uuid)) + .findFirst(); + } + + public boolean existsById(UUID uuid) { + return this.commande.stream() + .anyMatch(customer -> customer.getCommandeId().equals(uuid)); + } + + public void delete(Commande commande) { + this.commande.remove(commande); + } + + + public void deleteById(UUID uuid) { + this.commande.removeIf(commande -> commande.getClientId().equals(uuid)); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/CommandeUseCase.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/CommandeUseCase.java new file mode 100644 index 0000000..41d65fa --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/CommandeUseCase.java @@ -0,0 +1,73 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.usecase; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.converter.CommandeConverter; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.CommandeNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.repository.CommandeRepository; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.validator.CommandeValidator; + +import java.util.Optional; +import java.util.UUID; + +public class CommandeUseCase { + + private final CommandeRepository commandeRepository; + + public CommandeUseCase(CommandeRepository commandeRepository) { + this.commandeRepository = commandeRepository; + } + + + public UUID registerCommande(CommandeInfo validCommandeInfo, AdresseInfo validAdresseInfo){ + CommandeValidator.validate(validCommandeInfo); + CommandeValidator.validate(validAdresseInfo); + + Commande commandeToRegister = CommandeConverter.toDomain(validCommandeInfo,validAdresseInfo); + Commande commandeToRegistered = commandeRepository.save(commandeToRegister) ; + return commandeToRegistered.getCommandeId(); + + } + + public Optional findCommandByUUID(UUID uuid) { + Optional optionalCommande = commandeRepository.findById(uuid); + return optionalCommande.map(CommandeConverter::toDTO); + } + + public CommandeDTO updateCommande(UUID uuid, CommandeInfo commandeInfo, AdresseInfo adresseInfo) + throws CommandeNotFoundException, NotValidCommandeException { + CommandeValidator.validate(commandeInfo); + CommandeValidator.validate(adresseInfo); + Commande commandeByUUID = getCommandeIfDoesNotExistThrowCommandeNotFoundException( + uuid); + Commande commande = Commande.builder() + .clientId(commandeByUUID.getClientId()) + .lignesCommande(commandeInfo.listeLigne()) + .rue(adresseInfo.rue()) + .ville(adresseInfo.ville()) + .codePostal(adresseInfo.codePostal()) + .pays(adresseInfo.pays()) + .modePaiement(commandeInfo.modePayement()) + .commandeId(uuid) + .build(); + Commande updatedCommande = commandeRepository.save(commande); + return CommandeConverter.toDTO(updatedCommande); + } + + public void deleteCommande(UUID uuid) throws CommandeNotFoundException { + Commande commandeToDelete = getCommandeIfDoesNotExistThrowCommandeNotFoundException(uuid); + this.commandeRepository.delete(commandeToDelete); + } + + private Commande getCommandeIfDoesNotExistThrowCommandeNotFoundException(UUID uuid) + throws CommandeNotFoundException { + Optional optionalCommandeById = commandeRepository.findById(uuid); + if (optionalCommandeById.isEmpty()) { + throw new CommandeNotFoundException(uuid); + } + return optionalCommandeById.get(); + } +} diff --git a/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidator.java b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidator.java new file mode 100644 index 0000000..f93161c --- /dev/null +++ b/src/main/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidator.java @@ -0,0 +1,87 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidAdressException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidLigneCommandeException; + +import java.util.Objects; + +public final class CommandeValidator { + + public static final String LIGNE_COMMANDE_IS_NOT_VALIDE = "Ligne commande is not valide"; + public static final String MODE_PAIEMENT_IS_NOT_VALIDE = "Mode Paiement is not valide"; + public static final String LIST_LIGNE_COMANDE_IS_NOT_VALIDE = "List ligne commande is not valide"; + public static final String STREET_IS_NOT_VALIDE = "rue is not valide"; + + public static final String CITY_IS_NOT_VALIDE = "city is not valide"; + public static final String CODE_POSTAL_IS_NOT_VALIDE = "code postal is not valide"; + public static final String COUNTRY_IS_NOT_VALIDE = "Country is not valide"; + + + public static void validate(LigneCommandeInfo ligneCommandeInfo) { + if (ligneCommandeInfo.quantite()<=0){ + throw new NotValidLigneCommandeException(LIGNE_COMMANDE_IS_NOT_VALIDE); + } + } + + public static void validate(CommandeInfo commandeInfo) { + + validateModePaiement(commandeInfo); + validateListLigneCommande(commandeInfo); + } + + public static void validate(AdresseInfo adresseInfo) { + validateStreet(adresseInfo); + validateCity(adresseInfo); + validateCodePostal(adresseInfo); + validateCountry(adresseInfo); + } + + + + private static void validateModePaiement(CommandeInfo commandeInfo) { + if(commandeInfo.modePayement()!="CB"&& commandeInfo.modePayement()!="PAYPAL"&& commandeInfo.modePayement()!="POINTS_FIDELITE"){ + throw new NotValidCommandeException(MODE_PAIEMENT_IS_NOT_VALIDE); + } + } + + private static void validateListLigneCommande(CommandeInfo commandeInfo) { + if (commandeInfo.listeLigne() == null + || commandeInfo.listeLigne().isEmpty() + || commandeInfo.listeLigne().stream().anyMatch(Objects::isNull)){ + throw new NotValidCommandeException(LIST_LIGNE_COMANDE_IS_NOT_VALIDE); + } + + } + + private static void validateStreet(AdresseInfo adresseInfo) { + if (adresseInfo.rue() == null || adresseInfo.rue().isBlank()){ + throw new NotValidAdressException(STREET_IS_NOT_VALIDE); + } + } + private static void validateCity(AdresseInfo adresseInfo) { + if (adresseInfo.ville() == null || adresseInfo.ville().isBlank()){ + throw new NotValidAdressException(CITY_IS_NOT_VALIDE); + } + } + + private static void validateCodePostal(AdresseInfo adresseInfo) { + if (adresseInfo.codePostal() == null || adresseInfo.codePostal().isBlank()){ + throw new NotValidAdressException(CODE_POSTAL_IS_NOT_VALIDE); + } + } + + private static void validateCountry(AdresseInfo adresseInfo) { + if (adresseInfo.pays() == null || adresseInfo.pays().isBlank()){ + throw new NotValidAdressException(COUNTRY_IS_NOT_VALIDE); + } + } + + + + + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverterTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverterTest.java new file mode 100644 index 0000000..2381587 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/CommandeConverterTest.java @@ -0,0 +1,65 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.*; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; +import org.junit.jupiter.api.Test; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +public class CommandeConverterTest { + + + @Test + void TestConvertCommandeToDomain(){ + String modePaiement = ModePaiement.CB.name(); + List listLigne = new ArrayList<>(); + LigneCommandeInfo ligne = new LigneCommandeInfo(12); + LigneCommandeInfo ligne2 = new LigneCommandeInfo(14); + listLigne.add(ligne); + listLigne.add(ligne2); + CommandeInfo commandeInfo = new CommandeInfo(listLigne,modePaiement); + AdresseInfo adressInfo = new AdresseInfo("rue du cheval","La Rochette","77000","France"); + + + Commande result = CommandeConverter.toDomain(commandeInfo,adressInfo,modePaiement); + + + assertNotNull(result); + assertEquals(commandeInfo.listeLigne(), result.getLignesCommande()); + assertEquals(adressInfo.rue() , result.getRue()); + assertEquals(adressInfo.ville() , result.getVille()); + assertEquals(adressInfo.codePostal() , result.getCodePostal()); + assertEquals(adressInfo.pays() , result.getPays()); + assertEquals( modePaiement,result.getModePaiement()); + } + + @Test + void TestConvertCommandeToDTO(){ + String modePaiement = ModePaiement.CB.name(); + List listLigne = new ArrayList<>(); + LigneCommandeInfo ligne = new LigneCommandeInfo(12); + LigneCommandeInfo ligne2 = new LigneCommandeInfo(14); + listLigne.add(ligne); + listLigne.add(ligne2); + CommandeInfo commandeInfo = new CommandeInfo(listLigne,modePaiement); + AdresseInfo adressInfo = new AdresseInfo("rue du cheval","La Rochette","77000","France"); + + + CommandeDTO result = CommandeConverter.toDTO(commandeInfo,adressInfo,modePaiement); + + + assertNotNull(result); + assertEquals(commandeInfo.listeLigne(), result.getLignesCommande()); + assertEquals(adressInfo.rue() , result.getRue()); + assertEquals(adressInfo.ville() , result.getVille()); + assertEquals(adressInfo.codePostal() , result.getCodePostal()); + assertEquals(adressInfo.pays() , result.getPays()); + assertEquals( modePaiement,result.getModePaiement()); + } + + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverterTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverterTest.java new file mode 100644 index 0000000..b9a1873 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/converter/LigneCommandeConverterTest.java @@ -0,0 +1,35 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.converter; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeDTO; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.LigneCommande; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class LigneCommandeConverterTest { + + + @Test + void TestConvertLigneCommandeToDomain(){ + LigneCommandeInfo ligne = new LigneCommandeInfo(12); + + LigneCommande result = LigneCommandeConverter.toDomain(ligne); + + + assertEquals(ligne.quantite(),result.getQuantite()); + + } + + @Test + void TestConvertLigneCommandeToDTO(){ + LigneCommandeInfo ligne = new LigneCommandeInfo(12); + + LigneCommandeDTO result = LigneCommandeConverter.toDTO(ligne); + + + assertEquals(ligne.quantite(),result.getQuantite()); + + } + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/CommandeTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/CommandeTest.java new file mode 100644 index 0000000..36447bf --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/CommandeTest.java @@ -0,0 +1,104 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement; +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 java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +public class CommandeTest { + @Test + public void commandeTest(){ + + UUID clientId = UUID.randomUUID(); + List lignesCommande = new ArrayList<>(); + LigneCommandeInfo commande1 = new LigneCommandeInfo(12); + LigneCommandeInfo commande2 = new LigneCommandeInfo(13); + lignesCommande.add(commande1); + lignesCommande.add(commande2); + String rue = "rue du chien" ; + String ville = "LKa Rochette" ; + String codePostal = "7700" ; + String pays = "France" ; + String modePayement = ModePaiement.CB.name() ; + + Commande commande = Commande.builder() + .clientId(clientId) + .lignesCommande(lignesCommande) + .rue(rue) + .ville(ville) + .codePostal(codePostal) + .pays(pays) + .modePaiement(modePayement) + .build(); + + assertEquals(clientId, commande.getClientId()); + assertEquals(lignesCommande, commande.getLignesCommande()); + assertEquals(rue, commande.getRue()); + assertEquals(ville, commande.getVille()); + assertEquals(codePostal, commande.getCodePostal()); + assertEquals(pays, commande.getPays()); + assertEquals(modePayement, commande.getModePaiement()); + } + + + + @Test + @DisplayName("setRandomUUID should change the ID to a new random UUID") + void testSetRandomUUID() { + Commande commande = Commande.builder().build(); + UUID originalId = commande.getClientId(); + + commande.setRandomUUID(); + + assertNotNull(commande.getClientId()); + assertNotEquals(originalId, commande.getClientId()); + } + + @Test + @DisplayName("setRandomUUID should change the ID to a new random UUID") + void testSetRandomUUIDForCommande() { + Commande commande = Commande.builder().build(); + UUID originalId = commande.getCommandeId(); + + commande.setRandomUUIDCommande(); + + assertNotNull(commande.getCommandeId()); + assertNotEquals(originalId, commande.getCommandeId()); + } + + + @Test + void testConvertPointsFideliteGagnes(){ + Commande commande = Commande.builder() + .montantTotal(14.34) + .build(); + Integer point = commande.convertPointsFidelite(); + + assertEquals(point,(int) Math.ceil(commande.getMontantTotal())); + } + + @ParameterizedTest + @ValueSource(doubles = {-1.9,0.0}) + void testConvertPointsFideliteGagnesWhenMontantTotalIsNotGood(){ + Commande commande = Commande.builder() + .montantTotal(14.34) + .build(); + Integer point = commande.convertPointsFidelite(); + + assertEquals(point,(int) Math.ceil(commande.getMontantTotal())); + } + + + + + + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommandeTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommandeTest.java new file mode 100644 index 0000000..8ebaac4 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/entity/LigneCommandeTest.java @@ -0,0 +1,41 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.entity; + +import fr.iut_fbleau.but3.dev62.mylibrary.customer.entity.Customer; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +public class LigneCommandeTest { + + @Test + @DisplayName("Builder should create a valid LigneCommande instance") + void TestLigneCommande() { + UUID id = UUID.randomUUID(); + int quantite = 12; + + + LigneCommande ligneCommande = LigneCommande.builder() + .livreId(id) + .quantite(quantite) + .build(); + + assertEquals(id, ligneCommande.getLivreId()); + assertEquals(quantite, ligneCommande.getQuantite()); + + } + + @Test + @DisplayName("setRandomUUID should change the ID to a new random UUID") + void testSetRandomUUID() { + LigneCommande ligneCommande = LigneCommande.builder().build(); + UUID originalId = ligneCommande.getLivreId(); + + ligneCommande.setRandomUUID(); + + assertNotNull(ligneCommande.getLivreId()); + assertNotEquals(originalId, ligneCommande.getLivreId()); + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/CommandeNotFoundEsceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/CommandeNotFoundEsceptionTest.java new file mode 100644 index 0000000..946af6b --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/CommandeNotFoundEsceptionTest.java @@ -0,0 +1,50 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.CommandeNotFoundException; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class CommandeNotFoundEsceptionTest { + + @Test + @DisplayName("Exception message should contain the UUID provided") + void testExceptionMessageContainsUUID() { + UUID uuid = UUID.randomUUID(); + + CommandeNotFoundException exception = new CommandeNotFoundException(uuid); + + String expectedMessage = String.format("The commande with id %s does not exist", uuid); + assertEquals(expectedMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should use the correct constant message format") + void testExceptionUsesConstantMessageFormat() { + UUID uuid = UUID.randomUUID(); + + CommandeNotFoundException exception = new CommandeNotFoundException(uuid); + + String expectedFormatWithPlaceholder = "The commande with id {0} does not exist"; + assertEquals(CommandeNotFoundException.THE_COMMANDE_WITH_ID_DOES_NOT_EXIST_MESSAGE, + expectedFormatWithPlaceholder); + assertTrue(exception.getMessage().contains(uuid.toString())); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + UUID uuid = UUID.randomUUID(); + + try { + throw new CommandeNotFoundException(uuid); + } catch (CommandeNotFoundException e) { + String expectedMessage = String.format("The commande with id %s does not exist", uuid); + assertEquals(expectedMessage, e.getMessage()); + } + } +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidAdressExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidAdressExceptionTest.java new file mode 100644 index 0000000..69fecc7 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidAdressExceptionTest.java @@ -0,0 +1,67 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidAdressException; +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 NotValidAdressExceptionTest { + + @Test + @DisplayName("Exception should be created with the provided message") + void testExceptionCreation() { + String errorMessage = "Adresse is not valid"; + + NotValidAdressException exception = new NotValidAdressException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = { + "rue is not valide", + "city is not valide", + "code postal is not valide", + "Country is not valide" + }) + @DisplayName("Exception should handle different validation messages") + void testExceptionWithDifferentMessages(String errorMessage) { + NotValidAdressException exception = new NotValidAdressException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + String errorMessage = "Required field is missing"; + + Exception exception = assertThrows(NotValidAdressException.class, () -> { + throw new NotValidAdressException(errorMessage); + }); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be catchable as a general Exception") + void testExceptionInheritance() { + String errorMessage = "Invalid Adresse "; + + try { + throw new NotValidAdressException(errorMessage); + } catch (Exception e) { + assertEquals(NotValidAdressException.class, e.getClass()); + assertEquals(errorMessage, e.getMessage()); + } + } + + + + + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidCommandeExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidCommandeExceptionTest.java new file mode 100644 index 0000000..04c2020 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidCommandeExceptionTest.java @@ -0,0 +1,61 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException; +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 NotValidCommandeExceptionTest { + + @Test + @DisplayName("Exception should be created with the provided message") + void testExceptionCreation() { + String errorMessage = "Commande is not valid"; + + NotValidCommandeException exception = new NotValidCommandeException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @ParameterizedTest + @ValueSource(strings = { + "Mode Paiement is not valide", + "List ligne commande is not valide" + }) + @DisplayName("Exception should handle different validation messages") + void testExceptionWithDifferentMessages(String errorMessage) { + NotValidCommandeException exception = new NotValidCommandeException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + String errorMessage = "Required field is missing"; + + Exception exception = assertThrows(NotValidCommandeException.class, () -> { + throw new NotValidCommandeException(errorMessage); + }); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be catchable as a general Exception") + void testExceptionInheritance() { + String errorMessage = "Invalid Commande "; + + try { + throw new NotValidCommandeException(errorMessage); + } catch (Exception e) { + assertEquals(NotValidCommandeException.class, e.getClass()); + assertEquals(errorMessage, e.getMessage()); + } + } + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidLigneCommandeExceptionTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidLigneCommandeExceptionTest.java new file mode 100644 index 0000000..11fab22 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/exception/valid/NotValidLigneCommandeExceptionTest.java @@ -0,0 +1,47 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.valid; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidLigneCommandeException; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class NotValidLigneCommandeExceptionTest { + + @Test + @DisplayName("Exception should handle different validation messages") + void testExceptionCreation() { + String errorMessage = "Ligne commande is not valide"; + NotValidLigneCommandeException exception = new NotValidLigneCommandeException(errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be properly thrown and caught") + void testExceptionCanBeThrownAndCaught() { + String errorMessage = "Required field is missing"; + + Exception exception = assertThrows(NotValidLigneCommandeException.class, () -> { + throw new NotValidLigneCommandeException(errorMessage); + }); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + @DisplayName("Exception should be catchable as a general Exception") + void testExceptionInheritance() { + String errorMessage = "Invalid Commande "; + + try { + throw new NotValidLigneCommandeException(errorMessage); + } catch (Exception e) { + assertEquals(NotValidLigneCommandeException.class, e.getClass()); + assertEquals(errorMessage, e.getMessage()); + } + } + + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepositoryTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepositoryTest.java new file mode 100644 index 0000000..55d473e --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/repository/CommandeRepositoryTest.java @@ -0,0 +1,349 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.repository; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; +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.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + +public class CommandeRepositoryTest { + + private CommandeRepository repository; + private Commande commandeN1; + private Commande commandeN2; + private Commande commandeN3; + + @BeforeEach + void setUp() { + repository = new CommandeRepository(); + + UUID clientId = UUID.randomUUID(); + List lignesCommande = new ArrayList<>(); + LigneCommandeInfo commande1 = new LigneCommandeInfo(12); + LigneCommandeInfo commande2 = new LigneCommandeInfo(13); + lignesCommande.add(commande1); + lignesCommande.add(commande2); + String rue = "rue du chien"; + String ville = "LKa Rochette"; + String codePostal = "7700"; + String pays = "France"; + String modePayement = ModePaiement.CB.name(); + + commandeN1 = Commande.builder() + .clientId(clientId) + .lignesCommande(lignesCommande) + .rue(rue) + .ville(ville) + .codePostal(codePostal) + .pays(pays) + .modePaiement(modePayement) + .build(); + commandeN1.setRandomUUIDCommande(); + + + List lignesCommande2 = new ArrayList<>(); + LigneCommandeInfo commande3 = new LigneCommandeInfo(43); + LigneCommandeInfo commande4 = new LigneCommandeInfo(1); + lignesCommande2.add(commande3); + lignesCommande2.add(commande4); + + commandeN2 = Commande.builder() + .clientId(clientId) + .lignesCommande(lignesCommande2) + .rue(rue) + .ville(ville) + .codePostal(codePostal) + .pays(pays) + .modePaiement(modePayement) + .build(); + commandeN2.setRandomUUIDCommande(); + + List lignesCommande3 = new ArrayList<>(); + LigneCommandeInfo commande6 = new LigneCommandeInfo(12); + LigneCommandeInfo commande7 = new LigneCommandeInfo(13); + lignesCommande3.add(commande6); + lignesCommande3.add(commande7); + String rue2 = "rue du chevre chaud "; + String ville2 = "jsp"; + String codePostal2 = "77"; + String pays2 = "Lune "; + String modePayement2 = ModePaiement.PAYPAL.name(); + + commandeN3 = Commande.builder() + .lignesCommande(lignesCommande3) + .rue(rue2) + .ville(ville2) + .codePostal(codePostal2) + .pays(pays2) + .modePaiement(modePayement2) + .build(); + commandeN3.setRandomUUID(); + commandeN3.setRandomUUIDCommande(); + + } + + @Test + @DisplayName("New repository should be empty") + void testNewRepositoryIsEmpty() { + List commande = repository.findAll(); + + assertTrue(commande.isEmpty()); + assertEquals(0, commande.size()); + } + + + @Nested + @DisplayName("Save operations") + class SaveOperations { + @Test + @DisplayName("Save should add a new comande") + void testSaveNewCommande() { + Commande savedCommande = repository.save(commandeN1); + + assertEquals(1, repository.findAll().size()); + assertEquals(commandeN1.getCommandeId(), savedCommande.getCommandeId()); + assertEquals(commandeN1.getClientId(), savedCommande.getClientId()); + } + + + @Test + @DisplayName("Save should update existing commande with same ID") + void testSaveUpdatesExistingCommande() { + repository.save(commandeN1); + + + List lignesCommande2 = new ArrayList<>(); + LigneCommandeInfo commande3 = new LigneCommandeInfo(43); + LigneCommandeInfo commande4 = new LigneCommandeInfo(1); + lignesCommande2.add(commande3); + lignesCommande2.add(commande4); + + + UUID id = commandeN1.getCommandeId(); + Commande updatedCommande = Commande.builder() + .commandeId(id) + .lignesCommande(lignesCommande2) + .rue("rue") + .ville("moi") + .codePostal("1") + .pays("Russie") + .modePaiement(ModePaiement.POINTS_FIDELITE.name()) + .build(); + + Commande savedCommande = repository.save(updatedCommande); + + assertEquals(1, repository.findAll().size()); + assertEquals(id, savedCommande.getCommandeId()); + assertEquals("rue", savedCommande.getRue()); + assertEquals("moi", savedCommande.getVille()); + assertEquals("1", savedCommande.getCodePostal()); + assertEquals("Russie", savedCommande.getPays()); + assertEquals(ModePaiement.POINTS_FIDELITE.name(), savedCommande.getModePaiement()); + } + + @Test + @DisplayName("Save multiple customers should add all of them") + void testSaveMultipleCommande() { + repository.save(commandeN1); + repository.save(commandeN2); + + List commande = repository.findAll(); + + assertEquals(2, commande.size()); + assertTrue(commande.contains(commandeN1)); + assertTrue(commande.contains(commandeN2)); + } + } + + @Nested + @DisplayName("Find operations") + class FindOperations { + + @BeforeEach + void setUpCommande() { + repository.save(commandeN1); + repository.save(commandeN2); + } + + @Test + @DisplayName("FindAll should return all commande") + void testFindAll() { + List commande = repository.findAll(); + + assertEquals(2, commande.size()); + assertTrue(commande.contains(commandeN1)); + assertTrue(commande.contains(commandeN2)); + } + + @Test + @DisplayName("FindById should return commande with matching ID") + void testFindById() { + Optional foundCommande = repository.findById(commandeN1.getCommandeId()); + + assertTrue(foundCommande.isPresent()); + assertEquals(commandeN1.getCommandeId(), foundCommande.get().getCommandeId()); + assertEquals(commandeN1.getClientId(), foundCommande.get().getClientId()); + } + + @Test + void testFindByIdNotFound(){ + UUID nonExistentId = UUID.randomUUID(); + Optional foundCommande = repository.findById(nonExistentId); + + assertTrue(foundCommande.isEmpty()); + } + + + @Test + void testExistsByIdExists(){ + boolean exists = repository.existsById(commandeN1.getCommandeId()); + + assertTrue(exists); + + } + + @Test + void testExistsByIdNotExists(){ + UUID nonExistentId = UUID.randomUUID(); + boolean exists = repository.existsById(nonExistentId); + + assertFalse(exists); + } + } + + + + + @Nested + @DisplayName("Delete operations") + class DeleteOperations { + + + @BeforeEach + void setUpCustomers() { + repository.save(commandeN1); + repository.save(commandeN2); + repository.save(commandeN3); + } + + + @Test + @DisplayName("Delete should remove the specified customer") + void testDelete() { + repository.delete(commandeN1); + + List commande = repository.findAll(); + + assertEquals(2, commande.size()); + assertFalse(commande.contains(commandeN1)); + assertTrue(commande.contains(commandeN2)); + assertTrue(commande.contains(commandeN3)); + } + + @Test + @DisplayName("DeleteAll should remove all customers") + void testDeleteAll() { + repository.deleteAll(); + + List commande = repository.findAll(); + + assertTrue(commande.isEmpty()); + assertEquals(0, commande.size()); + } + + @Test + @DisplayName("Delete should not throw exception when customer doesn't exist") + void testDeleteNonExistentCustomer() { + + List lignesCommande = new ArrayList<>(); + LigneCommandeInfo commande1 = new LigneCommandeInfo(321); + LigneCommandeInfo commande2 = new LigneCommandeInfo(3); + lignesCommande.add(commande1); + lignesCommande.add(commande2); + + + Commande nonExistentCommande = Commande.builder() + .lignesCommande(lignesCommande) + .rue("non") + .ville("non") + .codePostal("Existent") + .pays("0000") + .modePaiement(ModePaiement.PAYPAL.name()) + .build(); + nonExistentCommande.setRandomUUIDCommande(); + + assertDoesNotThrow(() -> repository.delete(nonExistentCommande)); + + assertEquals(3, repository.findAll().size()); + } + + + @Test + void TestDeleteAllCommandeByCustomerID() { + System.out.println(commandeN1.getClientId()); + System.out.println(commandeN2.getClientId()); + System.out.println(commandeN3.getClientId()); + repository.deleteById(commandeN1.getClientId()); + + + List commande = repository.findAll(); + + assertEquals(1, commande.size()); + assertFalse(commande.contains(commandeN1)); + assertFalse(commande.contains(commandeN2)); + assertTrue(commande.contains(commandeN3)); + + + } + + + @Test + void TestDeleteAllCommandeByNonExistentCustomerID() { + + + List lignesCommande = new ArrayList<>(); + LigneCommandeInfo commande1 = new LigneCommandeInfo(321); + LigneCommandeInfo commande2 = new LigneCommandeInfo(3); + lignesCommande.add(commande1); + lignesCommande.add(commande2); + + + Commande nonExistentCommande = Commande.builder() + .lignesCommande(lignesCommande) + .rue("non") + .ville("non") + .codePostal("Existent") + .pays("0000") + .modePaiement(ModePaiement.PAYPAL.name()) + .build(); + nonExistentCommande.setRandomUUIDCommande(); + + + repository.deleteById(nonExistentCommande.getClientId()); + + + assertDoesNotThrow(() -> repository.findAll()); + + assertEquals(3, repository.findAll().size()); + + + } + + + } + + + + +} + + diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/TestCommandeUseCase.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/TestCommandeUseCase.java new file mode 100644 index 0000000..6e81a80 --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/usecase/TestCommandeUseCase.java @@ -0,0 +1,249 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.usecase; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.*; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.entity.Commande; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.CommandeNotFoundException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.repository.CommandeRepository; +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.util.ArrayList; +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.*; + + + +@ExtendWith(MockitoExtension.class) +public class TestCommandeUseCase { + + @Mock + private CommandeRepository commandeRepository; + + + @InjectMocks + private CommandeUseCase commandeUseCase; + + private UUID commandeId; + private UUID clientId; + private Commande testCommande; + private CommandeInfo validCommandeInfo; + private LigneCommandeInfo validLigneCommandeInfo; + private AdresseInfo validAdresseInfo; + private List lignesCommande; + private LigneCommandeInfo commande1; + private LigneCommandeInfo commande2; + private String rue; + private String ville; + private String codePostal; + private String pays; + private String modePayement; + + @BeforeEach + void setUp() { + + clientId = UUID.randomUUID(); + commandeId = UUID.randomUUID(); + lignesCommande = new ArrayList<>(); + commande1 = new LigneCommandeInfo(12); + commande2 = new LigneCommandeInfo(13); + lignesCommande.add(commande1); + lignesCommande.add(commande2); + rue = "rue du chien"; + ville = "LKa Rochette"; + codePostal = "7700"; + pays = "France"; + modePayement = ModePaiement.CB.name(); + + testCommande = Commande.builder() + .clientId(clientId) + .lignesCommande(lignesCommande) + .rue(rue) + .ville(ville) + .codePostal(codePostal) + .pays(pays) + .modePaiement(modePayement) + .commandeId(commandeId) + .build(); + + + validCommandeInfo = new CommandeInfo(lignesCommande,ModePaiement.CB.name()); + validLigneCommandeInfo= new LigneCommandeInfo(12); + validAdresseInfo = new AdresseInfo("rue du chien","LKa Rochette","7700","France"); + } + + + @Nested + class RegisterCommandeTest{ + + + @Test + void testRegisterCommandeWhitValidData(){ + when(commandeRepository.save(any(Commande.class))).thenReturn(testCommande); + + UUID registeredIsbn = commandeUseCase.registerCommande(validCommandeInfo,validAdresseInfo); + + assertNotNull(registeredIsbn); + assertEquals(commandeId, registeredIsbn); + verify(commandeRepository, times(1)).save(any(Commande.class)); + } + + @Test + void testRegisterCommandeWhitInvalidData(){ + CommandeInfo invalidCommandeInfo = new CommandeInfo(new ArrayList(),"pas bon "); + AdresseInfo invalidAdressInfo = new AdresseInfo(""," "," ",""); + + assertThrows(NotValidCommandeException.class, + ()->commandeUseCase.registerCommande(invalidCommandeInfo,invalidAdressInfo)); + verify(commandeRepository, never()).save(any(Commande.class)); + } + + + + } + + + @Nested + class FindCommandeTests { + @Test + @DisplayName("Should return book when isbn exists") + void testFindCommandByUUID() { + when(commandeRepository.findById(testCommande.getCommandeId())).thenReturn(Optional.of(testCommande)); + + Optional foundCommande = commandeUseCase.findCommandByUUID(testCommande.getCommandeId()); + + assertTrue(foundCommande.isPresent()); + assertEquals(testCommande.getCommandeId(), foundCommande.get().getCommandeId()); + verify(commandeRepository, times(1)).findById(testCommande.getCommandeId()); + } + + @Test + @DisplayName("Should return empty Optional when isbn doesn't exist") + void testFindCommandByUUIDNotFound() { + UUID uuid = UUID.randomUUID(); + when(commandeRepository.findById(uuid)).thenReturn(Optional.empty()); + + Optional foundCommande = commandeUseCase.findCommandByUUID(uuid); + + assertTrue(foundCommande.isEmpty()); + verify(commandeRepository, times(1)).findById(uuid); + } + } + + @Nested + class UpdateCommandeTests { + @Test + @DisplayName("Should update commande when valid data is provided") + void testUpdateCommandeWithValidData() throws CommandeNotFoundException, NotValidCommandeException { + when(commandeRepository.findById(commandeId)).thenReturn(Optional.of(testCommande)); + + Commande updatedCommande = Commande.builder() + .clientId(clientId) + .lignesCommande(lignesCommande) + .rue(rue) + .ville("Fontainebleau") + .codePostal("77300") + .pays(pays) + .modePaiement(modePayement) + .commandeId(commandeId) + .build(); + + when(commandeRepository.save(any(Commande.class))).thenReturn(updatedCommande); + + List updatelignesCommande = new ArrayList<>(); + LigneCommandeInfo updateLigneCommandeInfo= new LigneCommandeInfo(12); + updatelignesCommande.add(updateLigneCommandeInfo); + CommandeInfo updateInfo = new CommandeInfo(updatelignesCommande,ModePaiement.CB.name()); + AdresseInfo updateAdresseInfo = new AdresseInfo("rue du chien","Fontainebleau","77300","France"); + + CommandeDTO result = commandeUseCase.updateCommande(commandeId, updateInfo, updateAdresseInfo); + + assertNotNull(result); + assertEquals(commandeId, result.getCommandeId()); + assertEquals("Fontainebleau", result.getVille()); + assertEquals("77300", result.getCodePostal()); + verify(commandeRepository, times(1)).findById(commandeId); + verify(commandeRepository, times(1)).save(any(Commande.class)); + } + + @Test + @DisplayName("Should throw exception when commande ID doesn't exist") + void testUpdateCommandeNotFound() { + UUID nonExistentId = UUID.randomUUID(); + when(commandeRepository.findById(nonExistentId)).thenReturn(Optional.empty()); + + List updatelignesCommande = new ArrayList<>(); + LigneCommandeInfo updateLigneCommandeInfo= new LigneCommandeInfo(12); + updatelignesCommande.add(updateLigneCommandeInfo); + CommandeInfo updateInfo = new CommandeInfo(updatelignesCommande,ModePaiement.CB.name()); + AdresseInfo updateAdresseInfo = new AdresseInfo("rue du chien","Fontainebleau","77300","France"); + + assertThrows(CommandeNotFoundException.class, + () -> commandeUseCase.updateCommande(nonExistentId, updateInfo, updateAdresseInfo)); + + verify(commandeRepository, times(1)).findById(nonExistentId); + verify(commandeRepository, never()).save(any(Commande.class)); + } + + @Test + @DisplayName("Should throw exception when update data is not valid") + void testUpdateCommandeWithInvalidData() { + List updatelignesCommande = new ArrayList<>(); + LigneCommandeInfo updateLigneCommandeInfo= new LigneCommandeInfo(12); + updatelignesCommande.add(updateLigneCommandeInfo); + CommandeInfo invalidUpdateInfo = new CommandeInfo(updatelignesCommande, "CARTE"); + AdresseInfo updateAdresseInfo = new AdresseInfo("rue du chien","Fontainebleau","77300","France"); + + assertThrows(NotValidCommandeException.class, + () -> commandeUseCase.updateCommande(commandeId, invalidUpdateInfo, updateAdresseInfo)); + + verify(commandeRepository, never()).findById(any(UUID.class)); + verify(commandeRepository, never()).save(any(Commande.class)); + } + } + + + @Nested + class DeleteCommandeTests { + @Test + @DisplayName("Should delete commande when ID exists") + void testDeleteCommande() throws CommandeNotFoundException { + when(commandeRepository.findById(commandeId)).thenReturn(Optional.of(testCommande)); + doNothing().when(commandeRepository).delete(testCommande); + + commandeUseCase.deleteCommande(commandeId); + + verify(commandeRepository, times(1)).findById(commandeId); + verify(commandeRepository, times(1)).delete(testCommande); + } + + @Test + @DisplayName("Should throw exception when commande ID doesn't exist") + void testDeleteCustomerNotFound() { + UUID nonExistentId = UUID.randomUUID(); + when(commandeRepository.findById(nonExistentId)).thenReturn(Optional.empty()); + + assertThrows(CommandeNotFoundException.class, + () -> commandeUseCase.deleteCommande(nonExistentId)); + + verify(commandeRepository, times(1)).findById(nonExistentId); + verify(commandeRepository, never()).delete(any(Commande.class)); + } + } + + + + + +} diff --git a/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidatorTest.java b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidatorTest.java new file mode 100644 index 0000000..6faadeb --- /dev/null +++ b/src/test/java/fr/iut_fbleau/but3/dev62/mylibrary/commande/validator/CommandeValidatorTest.java @@ -0,0 +1,165 @@ +package fr.iut_fbleau.but3.dev62.mylibrary.commande.validator; + +import fr.iut_fbleau.but3.dev62.mylibrary.commande.AdresseInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.CommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.LigneCommandeInfo; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.ModePaiement; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidAdressException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidCommandeException; +import fr.iut_fbleau.but3.dev62.mylibrary.commande.exception.NotValidLigneCommandeException; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.*; + +import java.util.*; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; + +public class CommandeValidatorTest { + + + @Test + void testValidateValideLigneCommande () { + LigneCommandeInfo ligneCommandeValide = new LigneCommandeInfo(5); + + + assertDoesNotThrow(() -> CommandeValidator.validate(ligneCommandeValide)); + } + @ParameterizedTest + @ValueSource(ints = {-5,0 }) + void testValidateNotValideLigneCommande (int notValiteQuantite) { + LigneCommandeInfo ligneCommandeNotValide = new LigneCommandeInfo(notValiteQuantite); + NotValidLigneCommandeException exception = assertThrows( + NotValidLigneCommandeException.class, + () -> CommandeValidator.validate(ligneCommandeNotValide) + ); + + assertEquals(CommandeValidator.LIGNE_COMMANDE_IS_NOT_VALIDE, exception.getMessage()); + } + + + @ParameterizedTest + @EnumSource(value = ModePaiement.class, names = {"CB", "PAYPAL", "POINTS_FIDELITE"}) + void testValidateValideCommande(ModePaiement modePaiement) { + LigneCommandeInfo ligneCommandeValide = new LigneCommandeInfo(5); + List listeLigne = new ArrayList<>(); + listeLigne.add(ligneCommandeValide); + String modePaiementValide = modePaiement.toString(); + CommandeInfo commandeValid = new CommandeInfo(listeLigne, modePaiementValide); + + assertDoesNotThrow(() -> CommandeValidator.validate(commandeValid)); + } + + @ParameterizedTest + @ValueSource(strings = {"jambon", " ", ""}) + void testValidateNotValideModePaiement(String modePaiementError) { + LigneCommandeInfo ligneCommandeValide = new LigneCommandeInfo(5); + List listeLigne = new ArrayList<>(); + listeLigne.add(ligneCommandeValide); + String modePaiementValide = modePaiementError; + CommandeInfo commandeValid = new CommandeInfo(listeLigne, modePaiementValide); + + NotValidCommandeException exception = assertThrows( + NotValidCommandeException.class, + () -> CommandeValidator.validate(commandeValid) + ); + assertEquals(CommandeValidator.MODE_PAIEMENT_IS_NOT_VALIDE, exception.getMessage()); + } + + @ParameterizedTest + @MethodSource("provideInvalidOrderLists") + void testValidateNotValideListLigneCommande(List listeLigne) { + String modePaiementValide = ModePaiement.CB.toString(); + CommandeInfo commandeValid = new CommandeInfo(listeLigne, modePaiementValide); + NotValidCommandeException exception = assertThrows( + NotValidCommandeException.class, + () -> CommandeValidator.validate(commandeValid) + ); + assertEquals(CommandeValidator.LIST_LIGNE_COMANDE_IS_NOT_VALIDE, exception.getMessage()); + + } + static Stream provideInvalidOrderLists() { + return Stream.of( + Arguments.of(Collections.emptyList()), + Arguments.of(Arrays.asList(new LigneCommandeInfo(5), null, null, new LigneCommandeInfo(12))), + Arguments.of((List) null) + ); + } + + @Nested + class TestAdress{ + + + @Test + void testValidateValideLigneCommande () { + AdresseInfo adress = new AdresseInfo("rue du chien","La Rochette","7700","France"); + + assertDoesNotThrow(() -> CommandeValidator.validate(adress)); + } + + + + + @ParameterizedTest + @NullSource + @ValueSource(strings = {" ", " ", "\t", "\n"}) + void testValidateNotValideStreet(String notvalideStreet) { + AdresseInfo adress = new AdresseInfo(notvalideStreet,"La Rochette","7700","France"); + NotValidAdressException exception = assertThrows( + NotValidAdressException.class, + () -> CommandeValidator.validate(adress) + ); + assertEquals(CommandeValidator.STREET_IS_NOT_VALIDE, exception.getMessage()); + } + + @ParameterizedTest + @NullSource + @ValueSource(strings = {" ", " ", "\t", "\n"}) + void testValidateNotValideCity(String notvalideCity) { + AdresseInfo adress = new AdresseInfo("rue du chien",notvalideCity,"7700","France"); + NotValidAdressException exception = assertThrows( + NotValidAdressException.class, + () -> CommandeValidator.validate(adress) + ); + assertEquals(CommandeValidator.CITY_IS_NOT_VALIDE, exception.getMessage()); + } + + @ParameterizedTest + @NullSource + @ValueSource(strings = {" ", " ", "\t", "\n"}) + void testValidateNotValideCodePostal(String notvalideCodePostal) { + AdresseInfo adress = new AdresseInfo("rue du chien","La Rochette",notvalideCodePostal,"France"); + NotValidAdressException exception = assertThrows( + NotValidAdressException.class, + () -> CommandeValidator.validate(adress) + ); + assertEquals(CommandeValidator.CODE_POSTAL_IS_NOT_VALIDE, exception.getMessage()); + } + + @ParameterizedTest + @NullSource + @ValueSource(strings = {" ", " ", "\t", "\n"}) + void testValidateNotValideCountry(String notvalideCountry) { + AdresseInfo adress = new AdresseInfo("rue du chien","La Rochette","7700",notvalideCountry); + NotValidAdressException exception = assertThrows( + NotValidAdressException.class, + () -> CommandeValidator.validate(adress) + ); + assertEquals(CommandeValidator.COUNTRY_IS_NOT_VALIDE, exception.getMessage()); + } + + } + + + + + + + + + + + +}