diff --git a/src/main/java/br/com/db/petcontrol/controller/PetsController.java b/src/main/java/br/com/db/petcontrol/controller/PetsController.java new file mode 100644 index 0000000..ff110a8 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/controller/PetsController.java @@ -0,0 +1,31 @@ +package br.com.db.petcontrol.controller; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.media.Content; +import io.swagger.v3.oas.annotations.media.Schema; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; + +@Tag(name = "Pets", description = "Operações para gerenciamento de pets") +@RequestMapping("/pets") +public interface PetsController { + + @Operation(summary = "Cadastrar pet", description = "Cadastra um novo pet no sistema") + @ApiResponse( + responseCode = "201", + description = "Pet cadastrado com sucesso", + content = + @Content( + mediaType = "application/json", + schema = @Schema(implementation = PetResponseDTO.class))) + @ApiResponse(responseCode = "404", description = "Espécie não encontrada") + @PostMapping + ResponseEntity create(@Valid @RequestBody PetRequestDTO dto); +} diff --git a/src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java b/src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java new file mode 100644 index 0000000..91ce7bb --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java @@ -0,0 +1,23 @@ +package br.com.db.petcontrol.controller.impl; + +import br.com.db.petcontrol.controller.PetsController; +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.service.PetsService; +import lombok.RequiredArgsConstructor; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequiredArgsConstructor +public class PetsControllerImpl implements PetsController { + + private final PetsService petsService; + + @Override + public ResponseEntity create(PetRequestDTO dto) { + PetResponseDTO response = petsService.create(dto); + return ResponseEntity.status(HttpStatus.CREATED).body(response); + } +} diff --git a/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java b/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java new file mode 100644 index 0000000..ec12377 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java @@ -0,0 +1,22 @@ +package br.com.db.petcontrol.dto.request; + +import br.com.db.petcontrol.enums.PetStatus; +import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; +import java.util.List; +import java.util.UUID; +import lombok.Builder; + +@Builder +public record PetRequestDTO( + @NotBlank @Schema(description = "Nome do pet", example = "Lily") String name, + @NotNull + @Schema(description = "ID da espécie", example = "dd3af030-9823-40ff-bc6e-4de9eae55894") + UUID specieId, + @NotNull @Schema(description = "Status do pet", example = "AVAILABLE") PetStatus status, + @Schema( + description = "IDs das tags do pet", + example = + "[\"6231f3b7-e6c3-4e93-8890-4fc7dbc06101\", \"171402a5-71fd-42db-a680-df25187ac0c0\"]") + List tagsIds) {} diff --git a/src/main/java/br/com/db/petcontrol/dto/response/PetResponseDTO.java b/src/main/java/br/com/db/petcontrol/dto/response/PetResponseDTO.java new file mode 100644 index 0000000..b28fdef --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/dto/response/PetResponseDTO.java @@ -0,0 +1,19 @@ +package br.com.db.petcontrol.dto.response; + +import br.com.db.petcontrol.enums.PetStatus; +import io.swagger.v3.oas.annotations.media.Schema; +import java.util.List; +import java.util.UUID; +import lombok.Builder; + +@Builder +public record PetResponseDTO( + @Schema( + description = "Identificador único do pet", + example = "d6acb364-305e-4883-964f-0e7aee360684") + UUID id, + @Schema(description = "Nome do pet", example = "Lily") String name, + @Schema(description = "Status do pet", example = "AVAILABLE") PetStatus status, + @Schema(description = "Espécie do pet", example = "Gato") String species, + @Schema(description = "Tags do pet", example = "[\"castrado\", \"vacinado\"]") + List tags) {} diff --git a/src/main/java/br/com/db/petcontrol/enums/PetStatus.java b/src/main/java/br/com/db/petcontrol/enums/PetStatus.java new file mode 100644 index 0000000..a9f5237 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/enums/PetStatus.java @@ -0,0 +1,7 @@ +package br.com.db.petcontrol.enums; + +public enum PetStatus { + AVAILABLE, + IN_ANALYSIS, + ADOPTED +} diff --git a/src/main/java/br/com/db/petcontrol/exception/GlobalExceptionHandler.java b/src/main/java/br/com/db/petcontrol/exception/GlobalExceptionHandler.java index 29a6987..57d5bc9 100644 --- a/src/main/java/br/com/db/petcontrol/exception/GlobalExceptionHandler.java +++ b/src/main/java/br/com/db/petcontrol/exception/GlobalExceptionHandler.java @@ -14,7 +14,7 @@ public class GlobalExceptionHandler { @ExceptionHandler(NotFoundException.class) public ResponseEntity handleNotFoundException(NotFoundException ex) { - ErrorResponseDTO response = new ErrorResponseDTO(List.of(ex.getMessage())); + ErrorResponseDTO response = new ErrorResponseDTO(ex.getMessages()); return ResponseEntity.status(HttpStatus.NOT_FOUND).body(response); } diff --git a/src/main/java/br/com/db/petcontrol/exception/NotFoundException.java b/src/main/java/br/com/db/petcontrol/exception/NotFoundException.java index e5fe604..a5c8daf 100644 --- a/src/main/java/br/com/db/petcontrol/exception/NotFoundException.java +++ b/src/main/java/br/com/db/petcontrol/exception/NotFoundException.java @@ -1,7 +1,21 @@ package br.com.db.petcontrol.exception; +import java.util.List; + public class NotFoundException extends RuntimeException { + private final List messages; + public NotFoundException(String message) { super(message); + this.messages = List.of(message); + } + + public NotFoundException(List messages) { + super(messages.isEmpty() ? "Not found" : messages.get(0)); + this.messages = messages; + } + + public List getMessages() { + return messages; } } diff --git a/src/main/java/br/com/db/petcontrol/mapper/PetsMapper.java b/src/main/java/br/com/db/petcontrol/mapper/PetsMapper.java new file mode 100644 index 0000000..0ef61fb --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/mapper/PetsMapper.java @@ -0,0 +1,30 @@ +package br.com.db.petcontrol.mapper; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.model.Pets; +import br.com.db.petcontrol.model.Species; +import br.com.db.petcontrol.model.Tags; +import java.util.List; +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; + +@Mapper(componentModel = "spring") +public interface PetsMapper { + + @Mapping(target = "id", ignore = true) + @Mapping(target = "name", source = "dto.name") + @Mapping(target = "status", source = "dto.status") + Pets toEntity(PetRequestDTO dto, Species species, List tags); + + @Mapping(target = "species", source = "species.name") + @Mapping(target = "tags", source = "tags") + PetResponseDTO toResponse(Pets pet); + + default List map(List tags) { + if (tags == null) { + return null; + } + return tags.stream().map(Tags::getName).toList(); + } +} diff --git a/src/main/java/br/com/db/petcontrol/model/Pets.java b/src/main/java/br/com/db/petcontrol/model/Pets.java new file mode 100644 index 0000000..112e724 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/model/Pets.java @@ -0,0 +1,53 @@ +package br.com.db.petcontrol.model; + +import br.com.db.petcontrol.enums.PetStatus; +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.EnumType; +import jakarta.persistence.Enumerated; +import jakarta.persistence.FetchType; +import jakarta.persistence.GeneratedValue; +import jakarta.persistence.GenerationType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.JoinTable; +import jakarta.persistence.ManyToMany; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; +import java.util.List; +import java.util.UUID; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; + +@Entity +@Table(name = "tb_pets") +@Getter +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class Pets { + + @Id + @GeneratedValue(strategy = GenerationType.UUID) + private UUID id; + + @Column(nullable = false) + private String name; + + @Column(name = "status", nullable = false) + @Enumerated(EnumType.STRING) + private PetStatus status; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "species_id", nullable = false) + private Species species; + + @ManyToMany(fetch = FetchType.LAZY) + @JoinTable( + name = "tb_pet_tags", + joinColumns = @JoinColumn(name = "pet_id"), + inverseJoinColumns = @JoinColumn(name = "tag_id")) + private List tags; +} diff --git a/src/main/java/br/com/db/petcontrol/repository/PetsRepository.java b/src/main/java/br/com/db/petcontrol/repository/PetsRepository.java new file mode 100644 index 0000000..9560256 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/repository/PetsRepository.java @@ -0,0 +1,9 @@ +package br.com.db.petcontrol.repository; + +import br.com.db.petcontrol.model.Pets; +import java.util.UUID; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface PetsRepository extends JpaRepository {} diff --git a/src/main/java/br/com/db/petcontrol/service/PetsService.java b/src/main/java/br/com/db/petcontrol/service/PetsService.java new file mode 100644 index 0000000..6707f41 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/service/PetsService.java @@ -0,0 +1,8 @@ +package br.com.db.petcontrol.service; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; + +public interface PetsService { + PetResponseDTO create(PetRequestDTO dto); +} diff --git a/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java b/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java new file mode 100644 index 0000000..5f54df2 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java @@ -0,0 +1,66 @@ +package br.com.db.petcontrol.service.impl; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.exception.NotFoundException; +import br.com.db.petcontrol.mapper.PetsMapper; +import br.com.db.petcontrol.model.Pets; +import br.com.db.petcontrol.model.Species; +import br.com.db.petcontrol.model.Tags; +import br.com.db.petcontrol.repository.PetsRepository; +import br.com.db.petcontrol.repository.SpeciesRepository; +import br.com.db.petcontrol.repository.TagsRepository; +import br.com.db.petcontrol.service.PetsService; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +@Service +@RequiredArgsConstructor +public class PetsServiceImpl implements PetsService { + + private final PetsRepository petRepository; + private final SpeciesRepository speciesRepository; + private final TagsRepository tagRepository; + private final PetsMapper petsMapper; + + public PetResponseDTO create(PetRequestDTO dto) { + List errors = new ArrayList<>(); + + Species species = speciesRepository.findById(dto.specieId()).orElse(null); + if (species == null) { + errors.add("Species not found: " + dto.specieId()); + } + + List tags = findTagsOrCollectErrors(dto.tagsIds(), errors); + + if (!errors.isEmpty()) { + throw new NotFoundException(errors); + } + + Pets pet = petsMapper.toEntity(dto, species, tags); + Pets savedPet = petRepository.saveAndFlush(pet); + return petsMapper.toResponse(savedPet); + } + + private List findTagsOrCollectErrors(List ids, List errors) { + if (ids == null || ids.isEmpty()) { + return List.of(); + } + + List foundTags = tagRepository.findAllById(ids); + + if (foundTags.size() != ids.size()) { + List notFoundIds = + ids.stream() + .filter(id -> foundTags.stream().noneMatch(tag -> tag.getId().equals(id))) + .toList(); + + errors.add("Tags not found: " + notFoundIds); + } + + return foundTags; + } +} diff --git a/src/main/resources/db/migrations/V20260427110455__create_table_pets.sql b/src/main/resources/db/migrations/V20260427110455__create_table_pets.sql new file mode 100644 index 0000000..de9697b --- /dev/null +++ b/src/main/resources/db/migrations/V20260427110455__create_table_pets.sql @@ -0,0 +1,7 @@ +CREATE TABLE IF NOT EXISTS tb_pets ( + id UUID PRIMARY KEY DEFAULT uuid_generate_v4(), + name VARCHAR(100) NOT NULL, + status VARCHAR(50) NOT NULL, + species_id UUID NOT NULL, + CONSTRAINT fk_pet_species FOREIGN KEY (species_id) REFERENCES tb_species(id) +); diff --git a/src/main/resources/db/migrations/V20260427110525__create_table_pet_tags.sql b/src/main/resources/db/migrations/V20260427110525__create_table_pet_tags.sql new file mode 100644 index 0000000..c6f0ef7 --- /dev/null +++ b/src/main/resources/db/migrations/V20260427110525__create_table_pet_tags.sql @@ -0,0 +1,7 @@ +CREATE TABLE IF NOT EXISTS tb_pet_tags ( + pet_id UUID NOT NULL, + tag_id UUID NOT NULL, + PRIMARY KEY (pet_id, tag_id), + CONSTRAINT fk_pet_id FOREIGN KEY (pet_id) REFERENCES tb_pets(id), + CONSTRAINT fk_tag_id FOREIGN KEY (tag_id) REFERENCES tb_tags(id) +); \ No newline at end of file diff --git a/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java new file mode 100644 index 0000000..f20eb17 --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java @@ -0,0 +1,157 @@ +package br.com.db.petcontrol.controller; + +import static org.hamcrest.Matchers.hasSize; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +import br.com.db.petcontrol.controller.impl.PetsControllerImpl; +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.enums.PetStatus; +import br.com.db.petcontrol.mocks.PetsFixture; +import br.com.db.petcontrol.service.PetsService; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.http.MediaType; +import org.springframework.test.context.bean.override.mockito.MockitoBean; +import org.springframework.test.web.servlet.MockMvc; + +@WebMvcTest(PetsControllerImpl.class) +class PetsControllerTest { + + @Autowired private MockMvc mockMvc; + @Autowired private ObjectMapper objectMapper; + + @MockitoBean private PetsService petsService; + + private static final String PETS_URL = "/pets"; + + @Nested + class CreatePetTests { + + @Test + void shouldCreatePetAndReturnCreatedStatus() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(content().contentType(MediaType.APPLICATION_JSON)); + } + + @Test + void shouldReturnPetWithCorrectNameInResponse() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().name("Bolinha").build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().name("Bolinha").build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.name").value("Bolinha")); + } + + @Test + void shouldReturnPetWithCorrectIdInResponse() throws Exception { + UUID petId = UUID.randomUUID(); + PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().id(petId).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.id").value(petId.toString())); + } + + @Test + void shouldReturnPetWithCorrectStatusInResponse() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().status(PetStatus.AVAILABLE).build(); + PetResponseDTO response = + PetsFixture.responseDtoBuilder().status(PetStatus.AVAILABLE).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.status").value(PetStatus.AVAILABLE.name())); + } + + @Test + void shouldReturnPetWithCorrectSpeciesInResponse() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().species("Gato").build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.species").value("Gato")); + } + + @Test + void shouldReturnPetWithEmptyTagsInResponse() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().tagsIds(List.of()).build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().tags(List.of()).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.tags", hasSize(0))); + } + + @Test + void shouldCallServiceWithCorrectArguments() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()); + + verify(petsService).create(any(PetRequestDTO.class)); + } + } +} diff --git a/src/test/java/br/com/db/petcontrol/controller/SpeciesControllerTest.java b/src/test/java/br/com/db/petcontrol/controller/SpeciesControllerTest.java index 291947e..ce427da 100644 --- a/src/test/java/br/com/db/petcontrol/controller/SpeciesControllerTest.java +++ b/src/test/java/br/com/db/petcontrol/controller/SpeciesControllerTest.java @@ -16,8 +16,8 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; -import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.MediaType; +import org.springframework.test.context.bean.override.mockito.MockitoBean; import org.springframework.test.web.servlet.MockMvc; @WebMvcTest(SpeciesControllerImpl.class) @@ -25,7 +25,7 @@ class SpeciesControllerTest { @Autowired private MockMvc mockMvc; - @MockBean private SpeciesService service; + @MockitoBean private SpeciesService service; private static final String SPECIES_URL = "/species"; diff --git a/src/test/java/br/com/db/petcontrol/controller/TagsControllerTest.java b/src/test/java/br/com/db/petcontrol/controller/TagsControllerTest.java index d0c77e1..e40de0d 100644 --- a/src/test/java/br/com/db/petcontrol/controller/TagsControllerTest.java +++ b/src/test/java/br/com/db/petcontrol/controller/TagsControllerTest.java @@ -16,8 +16,8 @@ import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; -import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.http.MediaType; +import org.springframework.test.context.bean.override.mockito.MockitoBean; import org.springframework.test.web.servlet.MockMvc; @WebMvcTest(TagsControllerImpl.class) @@ -25,7 +25,7 @@ class TagsControllerTest { @Autowired private MockMvc mockMvc; - @MockBean private TagsService service; + @MockitoBean private TagsService service; private static final String TAGS_URL = "/tags"; diff --git a/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java b/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java new file mode 100644 index 0000000..f2eadcd --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java @@ -0,0 +1,266 @@ +package br.com.db.petcontrol.integration; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.enums.PetStatus; +import br.com.db.petcontrol.model.Species; +import br.com.db.petcontrol.model.Tags; +import br.com.db.petcontrol.repository.PetsRepository; +import br.com.db.petcontrol.repository.SpeciesRepository; +import br.com.db.petcontrol.repository.TagsRepository; +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.web.client.TestRestTemplate; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.test.context.ActiveProfiles; + +@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) +@ActiveProfiles("test") +class PetsIntegrationTest { + + @Autowired private TestRestTemplate restTemplate; + + @Autowired private PetsRepository petsRepository; + @Autowired private SpeciesRepository speciesRepository; + @Autowired private TagsRepository tagsRepository; + + private static final String PETS_URL = "/pets"; + + private Species savedSpecies; + + @BeforeEach + void setUp() { + petsRepository.deleteAll(); + tagsRepository.deleteAll(); + speciesRepository.deleteAll(); + savedSpecies = speciesRepository.save(new Species(null, "Cachorro")); + } + + @AfterEach + void tearDown() { + petsRepository.deleteAll(); + tagsRepository.deleteAll(); + speciesRepository.deleteAll(); + } + + @Nested + class CreatePetTests { + + @Test + void shouldCreatePetAndReturnCreatedStatus() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Rex") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody()).isNotNull(); + } + + @Test + void shouldCreatePetAndPersistInDatabase() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Bolinha") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertThat(petsRepository.findAll()).hasSize(1); + assertThat(petsRepository.findAll().getFirst().getName()).isEqualTo("Bolinha"); + } + + @Test + void shouldReturnPetWithCorrectName() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Luna") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody().name()).isEqualTo("Luna"); + } + + @Test + void shouldReturnPetWithGeneratedId() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Max") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody().id()).isNotNull(); + } + + @Test + void shouldReturnPetWithCorrectSpecies() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Thor") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody().species()).isEqualTo("Cachorro"); + } + + @Test + void shouldReturnPetWithCorrectStatus() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Mel") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody().status()).isEqualTo(PetStatus.AVAILABLE); + } + + @Test + void shouldCreatePetWithTags() { + Tags tag1 = tagsRepository.save(new Tags(null, "Vacinado")); + Tags tag2 = tagsRepository.save(new Tags(null, "Castrado")); + + PetRequestDTO request = + PetRequestDTO.builder() + .name("Pipoca") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of(tag1.getId(), tag2.getId())) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody().tags()).hasSize(2); + } + + @Test + void shouldCreatePetWithEmptyTags() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Trovão") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.CREATED, response.getStatusCode()); + assertThat(response.getBody().tags()).isEmpty(); + } + + @Test + void shouldReturnNotFoundWhenSpeciesDoesNotExist() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Rex") + .specieId(UUID.randomUUID()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode()); + } + + @Test + void shouldReturnNotFoundWhenSomeTagsDoNotExist() { + Tags tag1 = tagsRepository.save(new Tags(null, "Vacinado")); + UUID nonExistentTagId = UUID.randomUUID(); + + PetRequestDTO request = + PetRequestDTO.builder() + .name("Bingo") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of(tag1.getId(), nonExistentTagId)) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode()); + } + + @Test + void shouldReturnNotFoundWhenAllTagsDoNotExist() { + UUID nonExistentTagId1 = UUID.randomUUID(); + UUID nonExistentTagId2 = UUID.randomUUID(); + + PetRequestDTO request = + PetRequestDTO.builder() + .name("Spike") + .specieId(savedSpecies.getId()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of(nonExistentTagId1, nonExistentTagId2)) + .build(); + + ResponseEntity response = + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode()); + } + + @Test + void shouldNotPersistPetWhenSpeciesDoesNotExist() { + PetRequestDTO request = + PetRequestDTO.builder() + .name("Rex") + .specieId(UUID.randomUUID()) + .status(PetStatus.AVAILABLE) + .tagsIds(List.of()) + .build(); + + restTemplate.postForEntity(PETS_URL, request, PetResponseDTO.class); + + assertThat(petsRepository.findAll()).isEmpty(); + } + } +} diff --git a/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java b/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java new file mode 100644 index 0000000..fddcae1 --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java @@ -0,0 +1,42 @@ +package br.com.db.petcontrol.mocks; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.enums.PetStatus; +import br.com.db.petcontrol.model.Pets; +import java.util.List; +import java.util.UUID; + +public final class PetsFixture { + + private static final String DEFAULT_NAME = "Lily"; + private static final PetStatus DEFAULT_STATUS = PetStatus.AVAILABLE; + + private PetsFixture() {} + + public static Pets.PetsBuilder builder() { + return Pets.builder() + .id(UUID.randomUUID()) + .name(DEFAULT_NAME) + .status(DEFAULT_STATUS) + .species(SpeciesFixture.builder().build()) + .tags(List.of()); + } + + public static PetRequestDTO.PetRequestDTOBuilder requestDtoBuilder() { + return PetRequestDTO.builder() + .name(DEFAULT_NAME) + .specieId(UUID.randomUUID()) + .status(DEFAULT_STATUS) + .tagsIds(List.of()); + } + + public static PetResponseDTO.PetResponseDTOBuilder responseDtoBuilder() { + return PetResponseDTO.builder() + .id(UUID.randomUUID()) + .name(DEFAULT_NAME) + .status(DEFAULT_STATUS) + .species("Cachorro") + .tags(List.of()); + } +} diff --git a/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java new file mode 100644 index 0000000..fb95874 --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java @@ -0,0 +1,282 @@ +package br.com.db.petcontrol.service; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.dto.response.PetResponseDTO; +import br.com.db.petcontrol.enums.PetStatus; +import br.com.db.petcontrol.exception.NotFoundException; +import br.com.db.petcontrol.mapper.PetsMapper; +import br.com.db.petcontrol.mocks.PetsFixture; +import br.com.db.petcontrol.mocks.SpeciesFixture; +import br.com.db.petcontrol.mocks.TagsFixture; +import br.com.db.petcontrol.model.Pets; +import br.com.db.petcontrol.model.Species; +import br.com.db.petcontrol.model.Tags; +import br.com.db.petcontrol.repository.PetsRepository; +import br.com.db.petcontrol.repository.SpeciesRepository; +import br.com.db.petcontrol.repository.TagsRepository; +import br.com.db.petcontrol.service.impl.PetsServiceImpl; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; + +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.LENIENT) +class PetsServiceImplTest { + + @Mock private PetsRepository petRepository; + @Mock private SpeciesRepository speciesRepository; + @Mock private TagsRepository tagRepository; + @Mock private PetsMapper petsMapper; + + private PetsServiceImpl service; + + @BeforeEach + void setUp() { + service = new PetsServiceImpl(petRepository, speciesRepository, tagRepository, petsMapper); + } + + @Nested + class CreatePetTests { + + @Test + void shouldCreatePetSuccessfully() { + UUID speciesId = UUID.randomUUID(); + Species species = SpeciesFixture.builder().id(speciesId).name("Cachorro").build(); + PetRequestDTO dto = PetsFixture.requestDtoBuilder().specieId(speciesId).build(); + Pets expectedPet = PetsFixture.builder().species(species).build(); + PetResponseDTO expectedResponse = + PetsFixture.responseDtoBuilder().species("Cachorro").build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(expectedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(expectedPet); + when(petsMapper.toResponse(expectedPet)).thenReturn(expectedResponse); + + PetResponseDTO result = service.create(dto); + + assertThat(result).isNotNull(); + assertThat(result.name()).isEqualTo(expectedResponse.name()); + assertThat(result.species()).isEqualTo("Cachorro"); + } + + @Test + void shouldReturnPetWithCorrectId() { + UUID petId = UUID.randomUUID(); + UUID speciesId = UUID.randomUUID(); + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = PetsFixture.requestDtoBuilder().specieId(speciesId).build(); + Pets expectedPet = PetsFixture.builder().id(petId).species(species).build(); + PetResponseDTO expectedResponse = PetsFixture.responseDtoBuilder().id(petId).build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(expectedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(expectedPet); + when(petsMapper.toResponse(expectedPet)).thenReturn(expectedResponse); + + PetResponseDTO result = service.create(dto); + + assertThat(result.id()).isEqualTo(petId); + } + + @Test + void shouldThrowNotFoundExceptionWhenSpeciesDoesNotExist() { + UUID nonExistentSpeciesId = UUID.randomUUID(); + PetRequestDTO dto = PetsFixture.requestDtoBuilder().specieId(nonExistentSpeciesId).build(); + + when(speciesRepository.findById(nonExistentSpeciesId)).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> service.create(dto)) + .isInstanceOf(NotFoundException.class) + .hasMessageContaining("Species not found: " + nonExistentSpeciesId); + + verify(petRepository, never()).saveAndFlush(any()); + verify(petsMapper, never()).toEntity(any(), any(), anyList()); + } + + @Test + void shouldCreatePetWithTags() { + UUID speciesId = UUID.randomUUID(); + Tags tag1 = TagsFixture.builder().build(); + Tags tag2 = TagsFixture.builder().build(); + List tagIds = List.of(tag1.getId(), tag2.getId()); + List tags = List.of(tag1, tag2); + + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = + PetsFixture.requestDtoBuilder().specieId(speciesId).tagsIds(tagIds).build(); + Pets expectedPet = PetsFixture.builder().species(species).tags(tags).build(); + PetResponseDTO expectedResponse = + PetsFixture.responseDtoBuilder().tags(List.of(tag1.getName(), tag2.getName())).build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(tagIds)).thenReturn(tags); + when(petsMapper.toEntity(dto, species, tags)).thenReturn(expectedPet); + when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + when(petsMapper.toResponse(expectedPet)).thenReturn(expectedResponse); + + PetResponseDTO result = service.create(dto); + + assertThat(result.tags()).hasSize(2); + } + + @Test + void shouldCreatePetWithEmptyTagsList() { + UUID speciesId = UUID.randomUUID(); + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = + PetsFixture.requestDtoBuilder().specieId(speciesId).tagsIds(List.of()).build(); + Pets expectedPet = PetsFixture.builder().species(species).tags(List.of()).build(); + PetResponseDTO expectedResponse = PetsFixture.responseDtoBuilder().tags(List.of()).build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(expectedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(expectedPet); + when(petsMapper.toResponse(expectedPet)).thenReturn(expectedResponse); + + PetResponseDTO result = service.create(dto); + + assertThat(result.tags()).isEmpty(); + } + + @Test + void shouldCreatePetWithCorrectStatus() { + UUID speciesId = UUID.randomUUID(); + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = + PetsFixture.requestDtoBuilder().specieId(speciesId).status(PetStatus.AVAILABLE).build(); + Pets expectedPet = PetsFixture.builder().species(species).status(PetStatus.AVAILABLE).build(); + PetResponseDTO expectedResponse = + PetsFixture.responseDtoBuilder().status(PetStatus.AVAILABLE).build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(expectedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(expectedPet); + when(petsMapper.toResponse(expectedPet)).thenReturn(expectedResponse); + + PetResponseDTO result = service.create(dto); + + assertThat(result.status()).isEqualTo(PetStatus.AVAILABLE); + } + + @Test + void shouldCallAllRepositoriesWithCorrectArguments() { + UUID speciesId = UUID.randomUUID(); + Tags tag = TagsFixture.builder().build(); + List tagIds = List.of(tag.getId()); + List tags = List.of(tag); + + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = + PetsFixture.requestDtoBuilder().specieId(speciesId).tagsIds(tagIds).build(); + Pets expectedPet = PetsFixture.builder().build(); + PetResponseDTO expectedResponse = PetsFixture.responseDtoBuilder().build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(tagIds)).thenReturn(tags); + when(petsMapper.toEntity(dto, species, tags)).thenReturn(expectedPet); + when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + when(petsMapper.toResponse(expectedPet)).thenReturn(expectedResponse); + + service.create(dto); + + verify(speciesRepository).findById(speciesId); + verify(tagRepository).findAllById(tagIds); + verify(petsMapper).toEntity(dto, species, tags); + verify(petRepository).saveAndFlush(expectedPet); + verify(petsMapper).toResponse(expectedPet); + } + + @Test + void shouldReturnExactPetReturnedByRepository() { + UUID speciesId = UUID.randomUUID(); + UUID persistedId = UUID.randomUUID(); + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = PetsFixture.requestDtoBuilder().specieId(speciesId).build(); + Pets mappedPet = PetsFixture.builder().build(); + Pets persistedPet = PetsFixture.builder().id(persistedId).species(species).build(); + PetResponseDTO expectedResponse = PetsFixture.responseDtoBuilder().id(persistedId).build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(mappedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(persistedPet); + when(petsMapper.toResponse(persistedPet)).thenReturn(expectedResponse); + + PetResponseDTO result = service.create(dto); + + assertThat(result.id()).isEqualTo(persistedId); + } + + @Test + void shouldThrowNotFoundExceptionWhenSomeTagsDoNotExist() { + UUID speciesId = UUID.randomUUID(); + UUID tagId1 = UUID.randomUUID(); + UUID tagId2 = UUID.randomUUID(); + Tags tag1 = TagsFixture.builder().id(tagId1).build(); + + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = + PetsFixture.requestDtoBuilder() + .specieId(speciesId) + .tagsIds(List.of(tagId1, tagId2)) + .build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(List.of(tagId1, tagId2))).thenReturn(List.of(tag1)); + + assertThatThrownBy(() -> service.create(dto)) + .isInstanceOf(NotFoundException.class) + .hasMessageContaining("Tags not found"); + + verify(petRepository, never()).saveAndFlush(any()); + } + + @Test + void shouldThrowNotFoundExceptionWhenAllTagsDoNotExist() { + UUID speciesId = UUID.randomUUID(); + UUID tagId1 = UUID.randomUUID(); + UUID tagId2 = UUID.randomUUID(); + + Species species = SpeciesFixture.builder().id(speciesId).build(); + PetRequestDTO dto = + PetsFixture.requestDtoBuilder() + .specieId(speciesId) + .tagsIds(List.of(tagId1, tagId2)) + .build(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(List.of(tagId1, tagId2))).thenReturn(List.of()); + + assertThatThrownBy(() -> service.create(dto)) + .isInstanceOf(NotFoundException.class) + .hasMessageContaining("Tags not found"); + + verify(petRepository, never()).saveAndFlush(any()); + } + } +}