Agregamos test de use-cases y presentacion

src/main/java/com/outfitlab/project/domain/interfaces/repositories/GarmentRecomendationRepository.java

@@ -12,4 +12,6 @@ public interface GarmentRecomendationRepository {
     void deleteRecomendationsByGarmentCode(String garmentCode);
 
     void createSugerenciasByGarmentCode(String garmentCode, String type, List<String> sugerencias);
+
+    void deleteRecomendationByGarmentsCode(String garmentCodePrimary, String garmentCodeSecondary, String type);
 }

src/main/java/com/outfitlab/project/domain/model/UserModel.java

@@ -108,6 +108,10 @@ public UserModel(long id, String email) {
         this.email = email;
     }
 
+    public UserModel() {
+
+    }
+
     /*
      * public String getPassword() {
      * return "";

src/main/java/com/outfitlab/project/domain/useCases/recomendations/DeleteRecomendationByPrimaryAndSecondaryGarmentCode.java

@@ -0,0 +1,17 @@
+package com.outfitlab.project.domain.useCases.recomendations;
+
+import com.outfitlab.project.domain.interfaces.repositories.GarmentRecomendationRepository;
+
+public class DeleteRecomendationByPrimaryAndSecondaryGarmentCode {
+
+    private final GarmentRecomendationRepository garmentRecomendationRepository;
+
+    public DeleteRecomendationByPrimaryAndSecondaryGarmentCode(GarmentRecomendationRepository garmentRecomendationRepository) {
+        this.garmentRecomendationRepository = garmentRecomendationRepository;
+    }
+
+    public String execute(String garmentCodePrimary, String garmentCodeSecondary, String type) {
+        this.garmentRecomendationRepository.deleteRecomendationByGarmentsCode(garmentCodePrimary, garmentCodeSecondary, type);
+        return "Sugerencia eliminada con éxito.";
+    }
+}

src/main/java/com/outfitlab/project/infrastructure/config/RecomendationConfig.java

@@ -31,6 +31,11 @@ public PrendaOcacionRepository prendaOcacionRepository(PrendaOcacionJpaRepositor
         return new PrendaOcacionRepositoryImpl(prendaOcacionJpaRepository);
     }
 
+    @Bean
+    public DeleteRecomendationByPrimaryAndSecondaryGarmentCode deleteRecomendationByPrimaryAndSecondaryGarmentCode(GarmentRecomendationRepository recomendationRepository){
+        return new DeleteRecomendationByPrimaryAndSecondaryGarmentCode(recomendationRepository);
+    }
+
     @Bean
     public CreateSugerenciasByGarmentsCode createSugerenciasByGarmentsCode(GarmentRecomendationRepository garmentRecomendationRepository){
         return new CreateSugerenciasByGarmentsCode(garmentRecomendationRepository);

src/main/java/com/outfitlab/project/infrastructure/model/UserEntity.java

@@ -63,6 +63,9 @@ public class UserEntity implements UserDetails {
 
     public UserEntity() {
     }
+    public UserEntity(String email) {
+        this.email = email;
+    }
 
     public UserEntity(String name, String lastName, String email, String satulation, String secondName, Integer years,
             String password) {

src/main/java/com/outfitlab/project/infrastructure/repositories/GarmentRepositoryImpl.java

@@ -20,7 +20,7 @@
 
 public class GarmentRepositoryImpl implements GarmentRepository {
 
-    private final int PAGE_SIZE = 20;
+    private final int PAGE_SIZE = 10;
     private final GarmentJpaRepository garmentJpaRepository;
     private final BrandJpaRepository brandJpaRepository;
     private final ColorJpaRepository colorJpaRepository;

src/main/java/com/outfitlab/project/infrastructure/repositories/RecomendationRepositoryImpl.java

@@ -45,6 +45,14 @@ public void createSugerenciasByGarmentCode(String garmentCode, String type, List
         this.recomendationJpaRepository.saveAll(sugerenciasToCeate);
     }
 
+    @Override
+    public void deleteRecomendationByGarmentsCode(String garmentCodePrimary, String garmentCodeSecondary, String type) {
+        if (type.equalsIgnoreCase("inferior"))
+            this.recomendationJpaRepository.deleteWhenPrimaryIsBottom(garmentCodePrimary, garmentCodeSecondary);
+        else
+            this.recomendationJpaRepository.deleteWhenPrimaryIsTop(garmentCodePrimary, garmentCodeSecondary);
+    }
+
     private List<GarmentRecomendationEntity> getGarmentRecomendationEntitiesToCreate(String type, List<String> sugerencias, PrendaEntity prendaPrincipal) {
         List<GarmentRecomendationEntity> sugerenciasToCeate = new ArrayList<>();
 

src/main/java/com/outfitlab/project/infrastructure/repositories/UserGarmentFavoriteRepositoryImpl.java

@@ -19,7 +19,7 @@
 
 public class UserGarmentFavoriteRepositoryImpl implements UserGarmentFavoriteRepository {
 
-    private final int PAGE_SIZE = 20;
+    private final int PAGE_SIZE = 10;
     private final UserGarmentFavoriteJpaRepository userGarmentFavoriteJpaRepository;
     private final UserJpaRepository userJpaRepository;
     private final GarmentJpaRepository garmentJpaRepository;

src/main/java/com/outfitlab/project/infrastructure/repositories/UserRepositoryImpl.java

@@ -11,9 +11,7 @@
 import com.outfitlab.project.infrastructure.repositories.interfaces.UserJpaRepository;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
-
 import java.util.List;
-import java.util.Optional;
 
 import static com.outfitlab.project.domain.enums.Role.*; // ← Usar enums
 

src/main/java/com/outfitlab/project/infrastructure/repositories/interfaces/GarmentJpaRepository.java

@@ -7,7 +7,9 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
 import java.util.Optional;

src/main/java/com/outfitlab/project/infrastructure/repositories/interfaces/RecomendationJpaRepository.java

@@ -23,4 +23,25 @@ public interface RecomendationJpaRepository extends JpaRepository<GarmentRecomen
        OR gr.bottomGarment.garmentCode = :garmentCode
     """)
     void deleteAllByGarmentCode(@Param("garmentCode") String garmentCode);
+
+
+
+    @Modifying
+    @Transactional
+    @Query("""
+        delete from GarmentRecomendationEntity gr 
+        where gr.bottomGarment.garmentCode = :primaryCode
+          and gr.topGarment.garmentCode = :secondaryCode
+    """)
+    void deleteWhenPrimaryIsBottom(String primaryCode, String secondaryCode);
+
+
+    @Modifying
+    @Transactional
+    @Query("""
+        delete from GarmentRecomendationEntity gr 
+        where gr.topGarment.garmentCode = :primaryCode
+          and gr.bottomGarment.garmentCode = :secondaryCode
+    """)
+    void deleteWhenPrimaryIsTop(String primaryCode, String secondaryCode);
 }

src/main/java/com/outfitlab/project/presentation/RecomendationController.java

@@ -1,20 +1,21 @@
 package com.outfitlab.project.presentation;
 
+import com.outfitlab.project.domain.helper.CodeFormatter;
 import com.outfitlab.project.domain.useCases.garment.GetGarmentRecomendation;
+import com.outfitlab.project.domain.useCases.recomendations.DeleteRecomendationByPrimaryAndSecondaryGarmentCode;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 @RestController
 @RequestMapping("/api")
 public class RecomendationController {
 
     private final GetGarmentRecomendation getGarmentRecomendation;
+    private final DeleteRecomendationByPrimaryAndSecondaryGarmentCode deleteRecomendationByPrimaryAndSecondaryGarmentCode;
 
-    public RecomendationController(GetGarmentRecomendation getGarmentRecomendation) {
+    public RecomendationController(GetGarmentRecomendation getGarmentRecomendation, DeleteRecomendationByPrimaryAndSecondaryGarmentCode deleteRecomendationByPrimaryAndSecondaryGarmentCode) {
         this.getGarmentRecomendation = getGarmentRecomendation;
+        this.deleteRecomendationByPrimaryAndSecondaryGarmentCode = deleteRecomendationByPrimaryAndSecondaryGarmentCode;
     }
 
 
@@ -28,4 +29,15 @@ public ResponseEntity<?> getRecomendations(@PathVariable String garmentCode) {
                     .body(e.getMessage());
         }
     }
+
+    @DeleteMapping("/garment-recomendation/delete")
+    public ResponseEntity<?> deleteRecomendation(@RequestParam String garmentCodePrimary, @RequestParam String garmentCodeSecondary, @RequestParam String type) {
+        try {
+            return ResponseEntity.ok(this.deleteRecomendationByPrimaryAndSecondaryGarmentCode.execute(garmentCodePrimary, garmentCodeSecondary, type));
+        } catch (Exception e) {
+            return ResponseEntity
+                    .status(404)
+                    .body(e.getMessage());
+        }
+    }
 }

src/test/java/com/outfitlab/project/domain/useCases/brand/ActivateBrandTest.java

@@ -0,0 +1,75 @@
+package com.outfitlab.project.domain.useCases.brand;
+
+import com.outfitlab.project.domain.exceptions.BrandsNotFoundException;
+import com.outfitlab.project.domain.interfaces.repositories.BrandRepository;
+import com.outfitlab.project.domain.interfaces.repositories.UserRepository;
+import com.outfitlab.project.domain.model.BrandModel;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class ActivateBrandTest {
+
+    private BrandRepository brandRepository = mock(BrandRepository.class);
+    private UserRepository userRepository = mock(UserRepository.class);
+    private ActivateBrand activateBrand;
+
+    private final String BRAND_CODE = "adidas";
+    private final String USER_EMAIL = "adidas@corp.com";
+    private final String SUCCESS_MESSAGE = "Marca activada con éxito.";
+
+    @BeforeEach
+    void setUp() {
+        activateBrand = new ActivateBrand(brandRepository, userRepository);
+    }
+
+
+    @Test
+    public void shouldActivateUserAndReturnSuccessMessageWhenBrandExists() throws BrandsNotFoundException {
+        givenBrandExistsAndUserEmailIsAvailable(BRAND_CODE, USER_EMAIL);
+
+        String result = whenExecuteActivateBrand(BRAND_CODE);
+
+        thenResultIsSuccessMessage(result);
+        thenUserWasActivated(USER_EMAIL);
+    }
+
+    @Test
+    public void shouldThrowBrandsNotFoundExceptionWhenBrandDoesNotExist() {
+        givenBrandDoesNotExist(BRAND_CODE);
+
+        assertThrows(BrandsNotFoundException.class, () -> activateBrand.execute(BRAND_CODE));
+
+        thenActivationWasNeverCalled();
+    }
+
+
+    //privadosss
+    private void givenBrandExistsAndUserEmailIsAvailable(String brandCode, String userEmail) {
+        when(brandRepository.findByBrandCode(brandCode)).thenReturn(new BrandModel());
+        when(userRepository.getEmailUserRelatedToBrandByBrandCode(brandCode)).thenReturn(userEmail);
+    }
+
+    private void givenBrandDoesNotExist(String brandCode) {
+        when(brandRepository.findByBrandCode(brandCode)).thenReturn(null);
+    }
+
+    private String whenExecuteActivateBrand(String brandCode) {
+        return activateBrand.execute(brandCode);
+    }
+
+    private void thenResultIsSuccessMessage(String result) {
+        assertEquals(SUCCESS_MESSAGE, result, "El mensaje de retorno debe ser de activación exitosa.");
+    }
+
+    private void thenUserWasActivated(String userEmail) {
+        verify(userRepository, times(1)).getEmailUserRelatedToBrandByBrandCode(BRAND_CODE);
+        verify(userRepository, times(1)).activateUser(userEmail);
+    }
+
+    private void thenActivationWasNeverCalled() {
+        verify(userRepository, never()).activateUser(anyString());
+    }
+}

src/test/java/com/outfitlab/project/domain/useCases/brand/CreateBrandTest.java

@@ -0,0 +1,63 @@
+package com.outfitlab.project.domain.useCases.brand;
+
+import com.outfitlab.project.domain.interfaces.repositories.BrandRepository;
+import com.outfitlab.project.domain.model.BrandModel;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class CreateBrandTest {
+
+    private BrandRepository brandRepository = mock(BrandRepository.class);
+    private CreateBrand createBrand;
+
+    private final String BRAND_NAME = "Zara Shop";
+    private final String LOGO_URL = "http://logo.com/zara-shop.png";
+    private final String URL_SITE = "http://zarashop.com";
+    private final String EXPECTED_BRAND_CODE = "zara_shop";
+    private final String EXPECTED_RESPONSE = "brand-id-123";
+
+    @BeforeEach
+    void setUp() {
+        createBrand = new CreateBrand(brandRepository);
+    }
+
+
+    @Test
+    public void shouldCreateBrandModelWithFormattedCodeAndCallRepository() {
+        givenRepositoryReturnsExpectedResponse(EXPECTED_RESPONSE);
+
+        String result = whenExecuteCreateBrand(BRAND_NAME, LOGO_URL, URL_SITE);
+
+        thenRepositoryWasCalledWithCorrectBrandModel(BRAND_NAME, LOGO_URL, URL_SITE, EXPECTED_BRAND_CODE);
+        thenResultIsExpected(result, EXPECTED_RESPONSE);
+    }
+
+
+    //privadoss
+    private void givenRepositoryReturnsExpectedResponse(String response) {
+        when(brandRepository.createBrand(any(BrandModel.class))).thenReturn(response);
+    }
+
+    private String whenExecuteCreateBrand(String brandName, String logoUrl, String urlSite) {
+        return createBrand.execute(brandName, logoUrl, urlSite);
+    }
+
+    private void thenResultIsExpected(String actualResult, String expectedResponse) {
+        assertEquals(expectedResponse, actualResult, "El resultado debe ser la respuesta del repositorio.");
+    }
+
+    private void thenRepositoryWasCalledWithCorrectBrandModel(String expectedName, String expectedLogoUrl, String expectedUrlSite, String expectedCode) {
+        ArgumentCaptor<BrandModel> captor = ArgumentCaptor.forClass(BrandModel.class);
+        verify(brandRepository, times(1)).createBrand(captor.capture());
+
+        BrandModel capturedModel = captor.getValue();
+
+        assertEquals(expectedName, capturedModel.getNombre(), "El nombre de la marca debe coincidir.");
+        assertEquals(expectedLogoUrl, capturedModel.getLogoUrl(), "La URL del logo debe coincidir.");
+        assertEquals(expectedUrlSite, capturedModel.getUrlSite(), "La URL del sitio debe coincidir.");
+        assertEquals(expectedCode, capturedModel.getCodigoMarca(), "El código de marca debe estar formateado.");
+    }
+}

src/test/java/com/outfitlab/project/domain/useCases/brand/DesactivateBrandTest.java

@@ -0,0 +1,74 @@
+package com.outfitlab.project.domain.useCases.brand;
+
+import com.outfitlab.project.domain.exceptions.BrandsNotFoundException;
+import com.outfitlab.project.domain.interfaces.repositories.BrandRepository;
+import com.outfitlab.project.domain.interfaces.repositories.UserRepository;
+import com.outfitlab.project.domain.model.BrandModel;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class DesactivateBrandTest {
+
+    private BrandRepository brandRepository = mock(BrandRepository.class);
+    private UserRepository userRepository = mock(UserRepository.class);
+    private DesactivateBrand desactivateBrand;
+
+    private final String BRAND_CODE = "nike";
+    private final String USER_EMAIL = "nike@corp.com";
+    private final String SUCCESS_MESSAGE = "Marca desactivada con éxito.";
+
+    @BeforeEach
+    void setUp() {
+        desactivateBrand = new DesactivateBrand(brandRepository, userRepository);
+    }
+
+
+    @Test
+    public void shouldDesactivateUserAndReturnSuccessMessageWhenBrandExists() throws BrandsNotFoundException {
+        givenBrandExistsAndUserEmailIsAvailable(BRAND_CODE, USER_EMAIL);
+
+        String result = whenExecuteDesactivateBrand(BRAND_CODE);
+
+        thenResultIsSuccessMessage(result);
+        thenUserWasDesactivated(USER_EMAIL);
+    }
+
+    @Test
+    public void shouldThrowBrandsNotFoundExceptionWhenBrandDoesNotExist() {
+        givenBrandDoesNotExist(BRAND_CODE);
+
+        assertThrows(BrandsNotFoundException.class, () -> desactivateBrand.execute(BRAND_CODE));
+
+        thenDesactivationWasNeverCalled();
+    }
+
+
+    //privadoss
+    private void givenBrandExistsAndUserEmailIsAvailable(String brandCode, String userEmail) {
+        when(brandRepository.findByBrandCode(brandCode)).thenReturn(new BrandModel());
+        when(userRepository.getEmailUserRelatedToBrandByBrandCode(brandCode)).thenReturn(userEmail);
+    }
+
+    private void givenBrandDoesNotExist(String brandCode) {
+        when(brandRepository.findByBrandCode(brandCode)).thenReturn(null);
+    }
+
+    private String whenExecuteDesactivateBrand(String brandCode) {
+        return desactivateBrand.execute(brandCode);
+    }
+
+    private void thenResultIsSuccessMessage(String result) {
+        assertEquals(SUCCESS_MESSAGE, result, "El mensaje de retorno debe ser de desactivación exitosa.");
+    }
+
+    private void thenUserWasDesactivated(String userEmail) {
+        verify(userRepository, times(1)).getEmailUserRelatedToBrandByBrandCode(BRAND_CODE);
+        verify(userRepository, times(1)).desactivateUser(userEmail);
+    }
+
+    private void thenDesactivationWasNeverCalled() {
+        verify(userRepository, never()).desactivateUser(anyString());
+    }
+}