test(recipe): implementados test unitarios para repositorios, servicios y controladores de recetas

src/main/java/com/example/apprecetas/recipe/application/impl/UpdateRecipeUseCaseImpl.java

@@ -3,10 +3,7 @@ package com.example.apprecetas.recipe.application.impl;
 import com.example.apprecetas.recipe.application.UpdateRecipeUseCase;
 import com.example.apprecetas.recipe.domain.entity.Recipe;
 import com.example.apprecetas.recipe.domain.repository.UpdateRecipeRepository;
-import com.example.apprecetas.recipe.infrastructure.mapper.RecipeMapper;
-import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeDocument;
 import lombok.RequiredArgsConstructor;
-import org.mapstruct.factory.Mappers;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -15,8 +12,6 @@ public class UpdateRecipeUseCaseImpl implements UpdateRecipeUseCase {
 
     private final UpdateRecipeRepository repository;
 
-    private final RecipeMapper mapper = Mappers.getMapper(RecipeMapper.class);
-
     @Override
     public Recipe update(String id, Recipe recipe) {
         return repository.update(id, recipe);

src/main/java/com/example/apprecetas/recipe/domain/entity/Ingredient.java

 package com.example.apprecetas.recipe.domain.entity;
 
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 public class Ingredient {

src/main/java/com/example/apprecetas/recipe/domain/entity/Recipe.java

 package com.example.apprecetas.recipe.domain.entity;
 
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import java.time.LocalDateTime;
 import java.util.List;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 public class Recipe {

src/main/java/com/example/apprecetas/recipe/domain/entity/Step.java

 package com.example.apprecetas.recipe.domain.entity;
 
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 public class Step {

src/main/java/com/example/apprecetas/user/domain/entity/User.java

 package com.example.apprecetas.user.domain.entity;
 
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import java.time.LocalDate;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 public class User {

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/input/LoginRequest.java

@@ -2,9 +2,11 @@ package com.example.apprecetas.user.infrastructure.controller.dto.input;
 
 import jakarta.validation.constraints.NotEmpty;
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 public class LoginRequest {
     @NotEmpty(message = "Email obligatorio")

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/input/UserInputDto.java

@@ -5,10 +5,12 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Pattern;
 import jakarta.validation.constraints.Size;
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 public class UserInputDto {

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/output/AuthResponse.java

 package com.example.apprecetas.user.infrastructure.controller.dto.output;
 
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 public class AuthResponse {
     private String token;

src/main/java/com/example/apprecetas/user/infrastructure/controller/dto/output/UserOutputDto.java

@@ -2,12 +2,14 @@ package com.example.apprecetas.user.infrastructure.controller.dto.output;
 
 import com.example.apprecetas.user.domain.entity.Role;
 import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 import java.time.LocalDate;
 
-@Data
+@Getter
+@Setter
 @AllArgsConstructor
 @NoArgsConstructor
 public class UserOutputDto {

src/main/java/com/example/apprecetas/user/infrastructure/repository/mongodb/UserDocument.java

@@ -3,6 +3,7 @@ package com.example.apprecetas.user.infrastructure.repository.mongodb;
 import com.example.apprecetas.user.domain.entity.Role;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.mongodb.core.index.Indexed;
@@ -14,6 +15,7 @@ import java.time.LocalDate;
 @Getter
 @Setter
 @AllArgsConstructor
+@NoArgsConstructor
 public class UserDocument {
 
     @Id

src/test/java/com/example/apprecetas/recipe/application/CreateRecipeUseCaseImplTest.java

+package com.example.apprecetas.recipe.application;
+
+import com.example.apprecetas.recipe.application.impl.CreateRecipeUseCaseImpl;
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.domain.repository.CreateRecipeRepository;
+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 static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CreateRecipeUseCaseImplTest {
+
+    @Mock
+    private CreateRecipeRepository createRecipeRepository;
+
+    @InjectMocks
+    private CreateRecipeUseCaseImpl createRecipeUseCase;
+
+    @Test
+    void testCreate() {
+        Recipe recipe = createRecipe();
+        when(createRecipeRepository.create(any(Recipe.class))).thenReturn(recipe);
+        Recipe result = createRecipeUseCase.create(recipe);
+        assertNotNull(result);
+        verify(createRecipeRepository).create(any(Recipe.class));
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/application/DeleteRecipeUseCaseImplTest.java

+package com.example.apprecetas.recipe.application;
+
+import com.example.apprecetas.recipe.application.impl.DeleteRecipeUseCaseImpl;
+import com.example.apprecetas.recipe.domain.repository.DeleteRecipeRepository;
+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 static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class DeleteRecipeUseCaseImplTest {
+
+    @Mock
+    private DeleteRecipeRepository deleteRecipeRepository;
+
+    @InjectMocks
+    private DeleteRecipeUseCaseImpl deleteRecipeUseCase;
+
+    @Test
+    void testDelete() {
+        doNothing().when(deleteRecipeRepository).delete(anyString());
+        deleteRecipeUseCase.delete("RECIPE_ID");
+        verify(deleteRecipeRepository).delete(anyString());
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/application/ReadRecipeUseCaseImplTest.java

+package com.example.apprecetas.recipe.application;
+
+import com.example.apprecetas.recipe.application.impl.ReadRecipeUseCaseImpl;
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.domain.repository.ReadRecipeRepository;
+import com.example.apprecetas.user.domain.entity.User;
+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 org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.util.Collections;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class ReadRecipeUseCaseImplTest {
+
+    @Mock
+    private ReadRecipeRepository readRecipeRepository;
+
+    @InjectMocks
+    private ReadRecipeUseCaseImpl readRecipeUseCase;
+
+    @Test
+    void testReadById() {
+        Recipe recipe = createRecipe();
+        when(readRecipeRepository.readById(anyString())).thenReturn(recipe);
+
+        Recipe result = readRecipeUseCase.readById(recipe.getId());
+        assertNotNull(result);
+
+        verify(readRecipeRepository).readById(anyString());
+    }
+
+    @Test
+    void testReadAllByUser() {
+        Recipe recipe = createRecipe();
+        User user = createUser();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<Recipe> page = new PageImpl<>(Collections.singletonList(recipe));
+
+        when(readRecipeRepository.readAllByUser(anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<Recipe> result = readRecipeUseCase.readAllByUser(user.getId(), pageable);
+        assertNotNull(result);
+
+        verify(readRecipeRepository).readAllByUser(anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testReadFavoritesByUser() {
+        Recipe recipe = createRecipe();
+        User user = createUser();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<Recipe> page = new PageImpl<>(Collections.singletonList(recipe));
+
+        when(readRecipeRepository.readFavoritesByUser(anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<Recipe> result = readRecipeUseCase.readFavoritesByUser(user.getId(), pageable);
+        assertNotNull(result);
+
+        verify(readRecipeRepository).readFavoritesByUser(anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testSearchRecipes() {
+        Recipe recipe = createRecipe();
+        User user = createUser();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<Recipe> page = new PageImpl<>(Collections.singletonList(recipe));
+
+        when(readRecipeRepository.searchRecipes(anyString(), anyString(), anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<Recipe> result = readRecipeUseCase.searchRecipes(user.getId(), "", pageable);
+        assertNotNull(result);
+
+        verify(readRecipeRepository).searchRecipes(anyString(), anyString(), anyString(), any(Pageable.class));
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/application/UpdateRecipeUseCaseImplTest.java

+package com.example.apprecetas.recipe.application;
+
+import com.example.apprecetas.recipe.application.impl.UpdateRecipeUseCaseImpl;
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.domain.repository.UpdateRecipeRepository;
+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 static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class UpdateRecipeUseCaseImplTest {
+
+    @Mock
+    private UpdateRecipeRepository updateRecipeRepository;
+
+    @InjectMocks
+    private UpdateRecipeUseCaseImpl updateRecipeUseCase;
+
+    @Test
+    void testUpdate() {
+        Recipe recipe = createRecipe();
+
+        when(updateRecipeRepository.update(anyString(), any(Recipe.class))).thenReturn(recipe);
+
+        Recipe result = updateRecipeUseCase.update(recipe.getId(), recipe);
+        assertNotNull(result);
+
+        verify(updateRecipeRepository).update(anyString(), any(Recipe.class));
+    }
+
+    @Test
+    void testMadeFavorite() {
+        doNothing().when(updateRecipeRepository).madeFavorite(anyString());
+        updateRecipeUseCase.madeFavorite("RECIPE_ID");
+        verify(updateRecipeRepository).madeFavorite(anyString());
+    }
+
+    @Test
+    void testRemoveFavorite() {
+        doNothing().when(updateRecipeRepository).removeFavorite(anyString());
+        updateRecipeUseCase.removeFavorite("RECIPE_ID");
+        verify(updateRecipeRepository).removeFavorite(anyString());
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/controller/CreateRecipeControllerTest.java

+package com.example.apprecetas.recipe.infrastructure.controller;
+
+import com.example.apprecetas.exception.UnprocessableEntityException;
+import com.example.apprecetas.recipe.application.CreateRecipeUseCase;
+import com.example.apprecetas.recipe.application.FileUploadUseCase;
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.infrastructure.controller.dto.input.RecipeInputDto;
+import com.example.apprecetas.recipe.infrastructure.controller.dto.output.RecipeOutputDto;
+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 org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.BindingResult;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipeInputDto;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CreateRecipeControllerTest {
+
+    @Mock
+    private CreateRecipeUseCase createRecipeUseCase;
+
+    @Mock
+    private BindingResult result;
+
+    @InjectMocks
+    private CreateRecipeController controller;
+
+    @Test
+    void testCreateRecipe_WithErrors() {
+        when(result.hasErrors()).thenReturn(true);
+        assertThrows(UnprocessableEntityException.class, () -> controller.create(createRecipeInputDto(), result));
+        verify(result).hasErrors();
+    }
+
+    @Test
+    void testCreateRecipe() {
+        when(result.hasErrors()).thenReturn(false);
+        when(createRecipeUseCase.create(any(Recipe.class))).thenReturn(createRecipe());
+
+        ResponseEntity<RecipeOutputDto> response = controller.create(createRecipeInputDto(), result);
+        assertEquals(HttpStatus.CREATED, response.getStatusCode());
+
+        verify(result).hasErrors();
+        verify(createRecipeUseCase).create(any(Recipe.class));
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/controller/DeleteRecipeControllerTest.java

+package com.example.apprecetas.recipe.infrastructure.controller;
+
+import com.example.apprecetas.recipe.application.DeleteRecipeUseCase;
+import com.example.apprecetas.recipe.application.ReadRecipeUseCase;
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.user.domain.entity.User;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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 org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class DeleteRecipeControllerTest {
+
+    @Mock
+    private DeleteRecipeUseCase deleteRecipeUseCase;
+
+    @Mock
+    private ReadRecipeUseCase readRecipeUseCase;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @Mock
+    private Authentication authentication;
+
+    @InjectMocks
+    private DeleteRecipeController controller;
+
+    @BeforeEach
+    void setUp() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @AfterEach
+    void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @Test
+    void deleteRecipe_DistinctUser() {
+        User user = createUser();
+
+        when(readRecipeUseCase.readById(anyString())).thenReturn(createRecipe());
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+
+        ResponseEntity<String> response = controller.delete(user.getId());
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+
+        verify(readRecipeUseCase).readById(anyString());
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+    }
+
+    @Test
+    void deleteRecipe_SameUser() {
+        User user = createUser();
+        Recipe recipe = createRecipe();
+        recipe.setUserId(user.getId());
+
+        when(readRecipeUseCase.readById(anyString())).thenReturn(recipe);
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        doNothing().when(deleteRecipeUseCase).delete(anyString());
+
+        ResponseEntity<String> response = controller.delete(recipe.getUserId());
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(readRecipeUseCase).readById(anyString());
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(deleteRecipeUseCase).delete(anyString());
+    }
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/controller/ReadRecipeControllerTest.java

+package com.example.apprecetas.recipe.infrastructure.controller;
+
+import com.example.apprecetas.recipe.application.ReadRecipeUseCase;
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.infrastructure.controller.dto.output.RecipeListDto;
+import com.example.apprecetas.recipe.infrastructure.controller.dto.output.RecipeOutputDto;
+import com.example.apprecetas.user.domain.entity.User;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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 org.springframework.data.domain.*;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import java.util.List;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ReadRecipeControllerTest {
+
+    @Mock
+    private ReadRecipeUseCase service;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @Mock
+    private Authentication authentication;
+
+    @InjectMocks
+    private ReadRecipeController controller;
+
+    @BeforeEach
+    void setUp() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @AfterEach
+    void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @Test
+    void testReadById() {
+        Recipe recipe = createRecipe();
+        when(service.readById(anyString())).thenReturn(recipe);
+
+        ResponseEntity<RecipeOutputDto> response = controller.readById(recipe.getId());
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(service).readById(anyString());
+    }
+
+    @Test
+    void testReadAll() {
+        User user = createUser();
+        Recipe recipe = createRecipe();
+        Pageable pageable = PageRequest.of(0, 6, Sort.by("createdAt").descending());
+        Page<Recipe> page = new PageImpl<>(List.of(recipe), pageable, 10);
+
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.readAllByUser(anyString(), any(Pageable.class))).thenReturn(page);
+
+        ResponseEntity<Page<RecipeListDto>> response = controller.readAll(0, 6, "DESC");
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertNotNull(response.getBody());
+
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).readAllByUser(anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testReadFavorites() {
+        User user = createUser();
+        Recipe recipe = createRecipe();
+        Pageable pageable = PageRequest.of(0, 6, Sort.by("createdAt").descending());
+        Page<Recipe> page = new PageImpl<>(List.of(recipe), pageable, 10);
+
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.readFavoritesByUser(anyString(), any(Pageable.class))).thenReturn(page);
+
+        ResponseEntity<Page<RecipeListDto>> response = controller.readFavorites(0, 6, "DESC");
+
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertNotNull(response.getBody());
+
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).readFavoritesByUser(anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testSearchRecipes() {
+        User user = createUser();
+        Recipe recipe = createRecipe();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<Recipe> page = new PageImpl<>(List.of(recipe), pageable, 10);
+
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(service.searchRecipes(anyString(), anyString(), any(Pageable.class))).thenReturn(page);
+
+        ResponseEntity<Page<RecipeListDto>> response = controller.searchRecipes("tort", 0, 2);
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(service).searchRecipes(anyString(), anyString(), any(Pageable.class));
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/controller/UpdateRecipeControllerTest.java

+package com.example.apprecetas.recipe.infrastructure.controller;
+
+public class UpdateRecipeControllerTest {
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/repository/CreateRecipeRepositoryImplTest.java

+package com.example.apprecetas.recipe.infrastructure.repository;
+
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.infrastructure.controller.ReadRecipeController;
+import com.example.apprecetas.recipe.infrastructure.repository.impl.CreateRecipeRepositoryImpl;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeDocument;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeRepository;
+import com.example.apprecetas.user.domain.entity.User;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+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 org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipeDocument;
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CreateRecipeRepositoryImplTest {
+
+    @Mock
+    private RecipeRepository repository;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @Mock
+    private Authentication authentication;
+
+    @InjectMocks
+    private CreateRecipeRepositoryImpl repositoryImpl;
+
+    @BeforeEach
+    void setUp() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @AfterEach
+    void clearContext() {
+        SecurityContextHolder.clearContext();
+    }
+
+    @Test
+    void testCreate() {
+        User user = createUser();
+        Recipe recipe = createRecipe();
+
+        when(securityContext.getAuthentication()).thenReturn(authentication);
+        when(authentication.getName()).thenReturn(user.getId());
+        when(repository.save(any(RecipeDocument.class))).thenReturn(createRecipeDocument());
+
+        Recipe result = repositoryImpl.create(recipe);
+        assertNotNull(result);
+
+        verify(securityContext).getAuthentication();
+        verify(authentication).getName();
+        verify(repository).save(any(RecipeDocument.class));
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/repository/DeleteRecipeRepositoryImplTest.java

+package com.example.apprecetas.recipe.infrastructure.repository;
+
+import com.example.apprecetas.recipe.infrastructure.repository.impl.DeleteRecipeRepositoryImpl;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeDocument;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeRepository;
+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.Optional;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipeDocument;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class DeleteRecipeRepositoryImplTest {
+
+    @Mock
+    private RecipeRepository recipeRepository;
+
+    @InjectMocks
+    private DeleteRecipeRepositoryImpl deleteRecipeRepository;
+
+    @Test
+    void testDelete() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+
+        when(recipeRepository.findById(anyString())).thenReturn(Optional.of(recipeDocument));
+        doNothing().when(recipeRepository).delete(recipeDocument);
+
+        deleteRecipeRepository.delete("nombre");
+
+        verify(recipeRepository).findById(anyString());
+        verify(recipeRepository).delete(recipeDocument);
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/repository/ReadRecipeRepositoryImplTest.java

+package com.example.apprecetas.recipe.infrastructure.repository;
+
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.infrastructure.repository.impl.ReadRecipeRepositoryImpl;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeDocument;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeRepository;
+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 org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.util.Collections;
+import java.util.Optional;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipeDocument;
+import static com.example.apprecetas.utils.UserTestFactory.createUser;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ReadRecipeRepositoryImplTest {
+
+    @Mock
+    private RecipeRepository recipeRepository;
+
+    @InjectMocks
+    private ReadRecipeRepositoryImpl readRecipeRepository;
+
+    @Test
+    void testReadById() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+
+        when(recipeRepository.findById(anyString())).thenReturn(Optional.of(recipeDocument));
+
+        Recipe result = readRecipeRepository.readById(recipeDocument.getId());
+        assertNotNull(result);
+
+        verify(recipeRepository).findById(anyString());
+    }
+
+    @Test
+    void testReadAllByUser() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<RecipeDocument> page = new PageImpl<>(Collections.singletonList(recipeDocument));
+
+        when(recipeRepository.findByUserId(anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<Recipe> result = readRecipeRepository.readAllByUser(createUser().getId(), pageable);
+        assertNotNull(result);
+
+        verify(recipeRepository).findByUserId(anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testReadFavoritesByUser() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<RecipeDocument> page = new PageImpl<>(Collections.singletonList(recipeDocument));
+
+        when(recipeRepository.findByUserIdAndIsFavoriteTrue(anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<Recipe> result = readRecipeRepository.readFavoritesByUser(createUser().getId(), pageable);
+        assertNotNull(result);
+
+        verify(recipeRepository).findByUserIdAndIsFavoriteTrue(anyString(), any(Pageable.class));
+    }
+
+    @Test
+    void testSearchRecipes() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+        Pageable pageable = PageRequest.of(0, 10);
+        Page<RecipeDocument> page = new PageImpl<>(Collections.singletonList(recipeDocument));
+
+        when(recipeRepository.findByUserIdAndNameIgnoreCaseContainingOrIngredientsNameIgnoreCaseContaining(anyString(), anyString(), anyString(), any(Pageable.class))).thenReturn(page);
+
+        Page<Recipe> result = readRecipeRepository.searchRecipes(createUser().getId(), "", "", pageable);
+        assertNotNull(result);
+
+        verify(recipeRepository).findByUserIdAndNameIgnoreCaseContainingOrIngredientsNameIgnoreCaseContaining(anyString(), anyString(), anyString(), any(Pageable.class));
+    }
+
+}

src/test/java/com/example/apprecetas/recipe/infrastructure/repository/UpdateRecipeRepositoryImplTest.java

+package com.example.apprecetas.recipe.infrastructure.repository;
+
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.infrastructure.repository.impl.UpdateRecipeRepositoryImpl;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeDocument;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeRepository;
+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.Optional;
+
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipe;
+import static com.example.apprecetas.utils.RecipeTestFactory.createRecipeDocument;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class UpdateRecipeRepositoryImplTest {
+
+    @Mock
+    private RecipeRepository recipeRepository;
+
+    @InjectMocks
+    private UpdateRecipeRepositoryImpl updateRecipeRepository;
+
+    @Test
+    void testUpdate() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+
+        when(recipeRepository.findById(anyString())).thenReturn(Optional.of(recipeDocument));
+        when(recipeRepository.save(any(RecipeDocument.class))).thenReturn(recipeDocument);
+
+        Recipe result = updateRecipeRepository.update(recipeDocument.getId(), createRecipe());
+        assertNotNull(result);
+
+        verify(recipeRepository).findById(anyString());
+        verify(recipeRepository).save(any(RecipeDocument.class));
+    }
+
+    @Test
+    void testMadeFavorite() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+
+        when(recipeRepository.findById(anyString())).thenReturn(Optional.of(recipeDocument));
+        when(recipeRepository.save(any(RecipeDocument.class))).thenReturn(recipeDocument);
+
+        updateRecipeRepository.madeFavorite(recipeDocument.getId());
+
+        verify(recipeRepository).findById(anyString());
+        verify(recipeRepository).save(any(RecipeDocument.class));
+    }
+
+    @Test
+    void testRemoveFavorite() {
+        RecipeDocument recipeDocument = createRecipeDocument();
+
+        when(recipeRepository.findById(anyString())).thenReturn(Optional.of(recipeDocument));
+        when(recipeRepository.save(any(RecipeDocument.class))).thenReturn(recipeDocument);
+
+        updateRecipeRepository.removeFavorite(recipeDocument.getId());
+
+        verify(recipeRepository).findById(anyString());
+        verify(recipeRepository).save(any(RecipeDocument.class));
+    }
+
+}

src/test/java/com/example/apprecetas/utils/RecipeTestFactory.java

+package com.example.apprecetas.utils;
+
+import com.example.apprecetas.recipe.domain.entity.Recipe;
+import com.example.apprecetas.recipe.infrastructure.controller.dto.input.RecipeInputDto;
+import com.example.apprecetas.recipe.infrastructure.repository.mongodb.RecipeDocument;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+
+public class RecipeTestFactory {
+
+    public static RecipeInputDto createRecipeInputDto() {
+        return new RecipeInputDto(
+                "nombre",
+                "descripcion",
+                null,
+                new ArrayList<>(),
+                new ArrayList<>()
+        );
+    }
+
+    public static Recipe createRecipe() {
+        return new Recipe(
+                "id",
+                "nombre",
+                "descripcion",
+                null,
+                false,
+                LocalDateTime.now(),
+                new ArrayList<>(),
+                new ArrayList<>(),
+                "userId"
+        );
+    }
+
+    public static RecipeDocument createRecipeDocument() {
+        return new RecipeDocument(
+                "id",
+                "nombre",
+                "descripcion",
+                null,
+                false,
+                LocalDateTime.now(),
+                new ArrayList<>(),
+                new ArrayList<>(),
+                "userId"
+        );
+    }
+
+}