From b94ccaf6015b0ffdd6369fd48eb2cce9ae101793 Mon Sep 17 00:00:00 2001 From: Gabriela de Castro Laurindo Date: Mon, 27 Apr 2026 23:23:40 -0300 Subject: [PATCH 1/5] [PETCONTROL-001] feat: adicionar tabelas pets e pet_tags --- .../db/migrations/V20260427110455__create_table_pets.sql | 7 +++++++ .../migrations/V20260427110525__create_table_pet_tags.sql | 7 +++++++ 2 files changed, 14 insertions(+) create mode 100644 src/main/resources/db/migrations/V20260427110455__create_table_pets.sql create mode 100644 src/main/resources/db/migrations/V20260427110525__create_table_pet_tags.sql 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 From c5f894db46a10376d2999f6d563d6a412af47503 Mon Sep 17 00:00:00 2001 From: Gabriela de Castro Laurindo Date: Mon, 27 Apr 2026 23:24:58 -0300 Subject: [PATCH 2/5] =?UTF-8?q?[PETCONTROL-001]=20feat:=20implementar=20a?= =?UTF-8?q?=20cria=C3=A7=C3=A3o=20dos=20pets?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../petcontrol/controller/PetsController.java | 38 +++++++++++++ .../controller/impl/PetsControllerImpl.java | 25 +++++++++ .../petcontrol/dto/request/PetRequestDTO.java | 22 ++++++++ .../dto/response/PetResponseDTO.java | 19 +++++++ .../com/db/petcontrol/mapper/PetsMapper.java | 30 +++++++++++ .../java/br/com/db/petcontrol/model/Pets.java | 53 +++++++++++++++++++ .../db/petcontrol/model/enums/PetStatus.java | 7 +++ .../petcontrol/repository/PetsRepository.java | 9 ++++ .../db/petcontrol/service/PetsService.java | 8 +++ .../service/impl/PetsServiceImpl.java | 37 +++++++++++++ .../com/db/petcontrol/mocks/PetsFixture.java | 42 +++++++++++++++ 11 files changed, 290 insertions(+) create mode 100644 src/main/java/br/com/db/petcontrol/controller/PetsController.java create mode 100644 src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java create mode 100644 src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java create mode 100644 src/main/java/br/com/db/petcontrol/dto/response/PetResponseDTO.java create mode 100644 src/main/java/br/com/db/petcontrol/mapper/PetsMapper.java create mode 100644 src/main/java/br/com/db/petcontrol/model/Pets.java create mode 100644 src/main/java/br/com/db/petcontrol/model/enums/PetStatus.java create mode 100644 src/main/java/br/com/db/petcontrol/repository/PetsRepository.java create mode 100644 src/main/java/br/com/db/petcontrol/service/PetsService.java create mode 100644 src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java create mode 100644 src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java 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..af2b330 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/controller/PetsController.java @@ -0,0 +1,38 @@ +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( + @io.swagger.v3.oas.annotations.parameters.RequestBody( + description = "Dados do pet a ser cadastrado", + required = true, + content = @Content(schema = @Schema(implementation = PetRequestDTO.class))) + @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..1c77349 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java @@ -0,0 +1,25 @@ +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.mapper.PetsMapper; +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; + private final PetsMapper petsMapper; + + @Override + public ResponseEntity create(PetRequestDTO dto) { + PetResponseDTO response = petsMapper.toResponse(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..a01525b --- /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.model.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..9934f70 --- /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.model.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/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..fbce7b7 --- /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.model.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/model/enums/PetStatus.java b/src/main/java/br/com/db/petcontrol/model/enums/PetStatus.java new file mode 100644 index 0000000..738ef95 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/model/enums/PetStatus.java @@ -0,0 +1,7 @@ +package br.com.db.petcontrol.model.enums; + +public enum PetStatus { + AVAILABLE, + IN_ANALYSIS, + ADOPTED +} 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..8ee25b5 --- /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.model.Pets; + +public interface PetsService { + Pets 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..30e6ec8 --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java @@ -0,0 +1,37 @@ +package br.com.db.petcontrol.service.impl; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +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.List; +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 Pets create(PetRequestDTO dto) { + Species species = + speciesRepository + .findById(dto.specieId()) + .orElseThrow(() -> new NotFoundException("Species not found: " + dto.specieId())); + + List tags = tagRepository.findAllById(dto.tagsIds()); + + Pets pet = petsMapper.toEntity(dto, species, tags); + return petRepository.saveAndFlush(pet); + } +} 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..ec60a45 --- /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.model.Pets; +import br.com.db.petcontrol.model.enums.PetStatus; +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()); + } +} From 6e9382ba44364bbdc1ec88dc93d25b60af9cd609 Mon Sep 17 00:00:00 2001 From: Gabriela de Castro Laurindo Date: Tue, 28 Apr 2026 08:05:44 -0300 Subject: [PATCH 3/5] =?UTF-8?q?[PETCONTROL-001]=20test:=20adicionar=20test?= =?UTF-8?q?es=20unit=C3=A1rios=20e=20integra=C3=A7=C3=A3o=20para=20funcion?= =?UTF-8?q?alidade=20de=20pets?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/PetsControllerTest.java | 197 +++++++++++++++ .../integration/PetsIntegrationTest.java | 228 ++++++++++++++++++ .../service/PetsServiceImplTest.java | 208 ++++++++++++++++ 3 files changed, 633 insertions(+) create mode 100644 src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java create mode 100644 src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java create mode 100644 src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java 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..e7345d2 --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java @@ -0,0 +1,197 @@ +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.mapper.PetsMapper; +import br.com.db.petcontrol.mocks.PetsFixture; +import br.com.db.petcontrol.model.Pets; +import br.com.db.petcontrol.model.enums.PetStatus; +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; + @MockitoBean private PetsMapper petsMapper; + + 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(); + Pets createdPet = PetsFixture.builder().build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).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(); + Pets createdPet = PetsFixture.builder().name("Bolinha").build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().name("Bolinha").build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).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(); + Pets createdPet = PetsFixture.builder().id(petId).build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().id(petId).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).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(); + Pets createdPet = PetsFixture.builder().status(PetStatus.AVAILABLE).build(); + PetResponseDTO response = + PetsFixture.responseDtoBuilder().status(PetStatus.AVAILABLE).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).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(); + Pets createdPet = PetsFixture.builder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().species("Gato").build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).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 shouldReturnPetWithTagsInResponse() throws Exception { + PetRequestDTO request = + PetsFixture.requestDtoBuilder().tagsIds(List.of(UUID.randomUUID())).build(); + Pets createdPet = PetsFixture.builder().build(); + PetResponseDTO response = + PetsFixture.responseDtoBuilder().tags(List.of("Vacinado", "Castrado")).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.tags", hasSize(2))) + .andExpect(jsonPath("$.tags[0]").value("Vacinado")) + .andExpect(jsonPath("$.tags[1]").value("Castrado")); + } + + @Test + void shouldReturnPetWithEmptyTagsInResponse() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().tagsIds(List.of()).build(); + Pets createdPet = PetsFixture.builder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().tags(List.of()).build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).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 shouldCallServiceAndMapperWithCorrectArguments() throws Exception { + PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); + Pets createdPet = PetsFixture.builder().build(); + PetResponseDTO response = PetsFixture.responseDtoBuilder().build(); + + when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); + when(petsMapper.toResponse(createdPet)).thenReturn(response); + + mockMvc + .perform( + post(PETS_URL) + .contentType(MediaType.APPLICATION_JSON) + .content(objectMapper.writeValueAsString(request))) + .andExpect(status().isCreated()); + + verify(petsService).create(any(PetRequestDTO.class)); + verify(petsMapper).toResponse(createdPet); + } + } +} 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..2cbc9ff --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java @@ -0,0 +1,228 @@ +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.model.Species; +import br.com.db.petcontrol.model.Tags; +import br.com.db.petcontrol.model.enums.PetStatus; +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 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/service/PetsServiceImplTest.java b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java new file mode 100644 index 0000000..c905f9e --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java @@ -0,0 +1,208 @@ +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.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.model.enums.PetStatus; +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; + +@ExtendWith(MockitoExtension.class) +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(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(dto.tagsIds())).thenReturn(List.of()); + when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); + when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + + Pets result = service.create(dto); + + assertThat(result).isNotNull(); + assertThat(result.getName()).isEqualTo(expectedPet.getName()); + assertThat(result.getSpecies()).isEqualTo(species); + } + + @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(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); + when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + + Pets result = service.create(dto); + + assertThat(result.getId()).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(); + + 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); + + Pets result = service.create(dto); + + assertThat(result.getTags()).hasSize(2).containsExactlyInAnyOrder(tag1, tag2); + } + + @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(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(List.of())).thenReturn(List.of()); + when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); + when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + + Pets result = service.create(dto); + + assertThat(result.getTags()).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(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); + when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + + Pets result = service.create(dto); + + assertThat(result.getStatus()).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(); + + 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); + + service.create(dto); + + verify(speciesRepository).findById(speciesId); + verify(tagRepository).findAllById(tagIds); + verify(petsMapper).toEntity(dto, species, tags); + verify(petRepository).saveAndFlush(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(); + + when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); + when(tagRepository.findAllById(anyList())).thenReturn(List.of()); + when(petsMapper.toEntity(any(), any(), anyList())).thenReturn(mappedPet); + when(petRepository.saveAndFlush(mappedPet)).thenReturn(persistedPet); + + Pets result = service.create(dto); + + assertThat(result.getId()).isEqualTo(persistedId); + } + } +} From acfd638276eab462eba85c915ad8974fd252127b Mon Sep 17 00:00:00 2001 From: Gabriela de Castro Laurindo Date: Tue, 28 Apr 2026 09:57:30 -0300 Subject: [PATCH 4/5] =?UTF-8?q?[PETCONTROL-001]=20refactor:=20implementada?= =?UTF-8?q?=20valida=C3=A7=C3=B5es=20e=20ajustes=20nos=20testes?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../petcontrol/dto/request/PetRequestDTO.java | 2 + .../exception/GlobalExceptionHandler.java | 2 +- .../exception/NotFoundException.java | 14 +++ .../service/impl/PetsServiceImpl.java | 30 ++++- .../PetStatusForCreationValidator.java | 34 ++++++ .../ValidPetStatusForCreation.java | 21 ++++ .../controller/PetsControllerTest.java | 22 ---- .../integration/PetsIntegrationTest.java | 38 ++++++ .../service/PetsServiceImplTest.java | 79 +++++++++++-- .../PetStatusForCreationValidatorTest.java | 111 ++++++++++++++++++ 10 files changed, 313 insertions(+), 40 deletions(-) create mode 100644 src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java create mode 100644 src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java create mode 100644 src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java 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 index a01525b..37985d2 100644 --- a/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java +++ b/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java @@ -1,6 +1,7 @@ package br.com.db.petcontrol.dto.request; import br.com.db.petcontrol.model.enums.PetStatus; +import br.com.db.petcontrol.validation.petstatusforcreation.ValidPetStatusForCreation; import io.swagger.v3.oas.annotations.media.Schema; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.NotNull; @@ -9,6 +10,7 @@ import lombok.Builder; @Builder +@ValidPetStatusForCreation public record PetRequestDTO( @NotBlank @Schema(description = "Nome do pet", example = "Lily") String name, @NotNull 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/service/impl/PetsServiceImpl.java b/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java index 30e6ec8..c10011d 100644 --- a/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java +++ b/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java @@ -10,7 +10,9 @@ 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; @@ -24,12 +26,30 @@ public class PetsServiceImpl implements PetsService { private final PetsMapper petsMapper; public Pets create(PetRequestDTO dto) { - Species species = - speciesRepository - .findById(dto.specieId()) - .orElseThrow(() -> new NotFoundException("Species not found: " + dto.specieId())); + List errors = new ArrayList<>(); - List tags = tagRepository.findAllById(dto.tagsIds()); + Species species = speciesRepository.findById(dto.specieId()).orElse(null); + if (species == null) { + errors.add("Species not found: " + dto.specieId()); + } + + List tags = List.of(); + if (dto.tagsIds() != null && !dto.tagsIds().isEmpty()) { + List foundTags = tagRepository.findAllById(dto.tagsIds()); + if (foundTags.size() != dto.tagsIds().size()) { + List notFoundIds = + dto.tagsIds().stream() + .filter(id -> foundTags.stream().noneMatch(tag -> tag.getId().equals(id))) + .toList(); + errors.add("Tags not found: " + notFoundIds); + } else { + tags = foundTags; + } + } + + if (!errors.isEmpty()) { + throw new NotFoundException(errors); + } Pets pet = petsMapper.toEntity(dto, species, tags); return petRepository.saveAndFlush(pet); diff --git a/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java b/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java new file mode 100644 index 0000000..af7558c --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java @@ -0,0 +1,34 @@ +package br.com.db.petcontrol.validation.petstatusforcreation; + +import br.com.db.petcontrol.dto.request.PetRequestDTO; +import br.com.db.petcontrol.model.enums.PetStatus; +import jakarta.validation.ConstraintValidator; +import jakarta.validation.ConstraintValidatorContext; + +public class PetStatusForCreationValidator + implements ConstraintValidator { + private String message; + + @Override + public void initialize(ValidPetStatusForCreation annotation) { + this.message = annotation.message(); + } + + @Override + public boolean isValid(PetRequestDTO dto, ConstraintValidatorContext context) { + if (dto == null || dto.status() == null) { + return true; + } + + boolean isValid = dto.status() == PetStatus.AVAILABLE; + + if (!isValid) { + context.disableDefaultConstraintViolation(); + context + .buildConstraintViolationWithTemplate(this.message + ", but got: " + dto.status()) + .addConstraintViolation(); + } + + return isValid; + } +} diff --git a/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java b/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java new file mode 100644 index 0000000..a0b54ef --- /dev/null +++ b/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java @@ -0,0 +1,21 @@ +package br.com.db.petcontrol.validation.petstatusforcreation; + +import jakarta.validation.Constraint; +import jakarta.validation.Payload; +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Documented +@Constraint(validatedBy = PetStatusForCreationValidator.class) +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface ValidPetStatusForCreation { + String message() default "Pet can only be created with status AVAILABLE"; + + Class[] groups() default {}; + + Class[] payload() default {}; +} diff --git a/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java index e7345d2..03da095 100644 --- a/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java +++ b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java @@ -134,28 +134,6 @@ void shouldReturnPetWithCorrectSpeciesInResponse() throws Exception { .andExpect(jsonPath("$.species").value("Gato")); } - @Test - void shouldReturnPetWithTagsInResponse() throws Exception { - PetRequestDTO request = - PetsFixture.requestDtoBuilder().tagsIds(List.of(UUID.randomUUID())).build(); - Pets createdPet = PetsFixture.builder().build(); - PetResponseDTO response = - PetsFixture.responseDtoBuilder().tags(List.of("Vacinado", "Castrado")).build(); - - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); - - mockMvc - .perform( - post(PETS_URL) - .contentType(MediaType.APPLICATION_JSON) - .content(objectMapper.writeValueAsString(request))) - .andExpect(status().isCreated()) - .andExpect(jsonPath("$.tags", hasSize(2))) - .andExpect(jsonPath("$.tags[0]").value("Vacinado")) - .andExpect(jsonPath("$.tags[1]").value("Castrado")); - } - @Test void shouldReturnPetWithEmptyTagsInResponse() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().tagsIds(List.of()).build(); diff --git a/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java b/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java index 2cbc9ff..7bc38d9 100644 --- a/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java +++ b/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java @@ -210,6 +210,44 @@ void shouldReturnNotFoundWhenSpeciesDoesNotExist() { 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 = diff --git a/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java index c905f9e..b0be4da 100644 --- a/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java +++ b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java @@ -31,8 +31,11 @@ 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; @@ -58,9 +61,10 @@ void shouldCreatePetSuccessfully() { Pets expectedPet = PetsFixture.builder().species(species).build(); when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); - when(tagRepository.findAllById(dto.tagsIds())).thenReturn(List.of()); - when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); - when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + 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); Pets result = service.create(dto); @@ -79,8 +83,9 @@ void shouldReturnPetWithCorrectId() { when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); when(tagRepository.findAllById(anyList())).thenReturn(List.of()); - when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); - when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(expectedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(expectedPet); Pets result = service.create(dto); @@ -134,9 +139,10 @@ void shouldCreatePetWithEmptyTagsList() { Pets expectedPet = PetsFixture.builder().species(species).tags(List.of()).build(); when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); - when(tagRepository.findAllById(List.of())).thenReturn(List.of()); - when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); - when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + 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); Pets result = service.create(dto); @@ -153,8 +159,9 @@ void shouldCreatePetWithCorrectStatus() { when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); when(tagRepository.findAllById(anyList())).thenReturn(List.of()); - when(petsMapper.toEntity(dto, species, List.of())).thenReturn(expectedPet); - when(petRepository.saveAndFlush(expectedPet)).thenReturn(expectedPet); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(expectedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(expectedPet); Pets result = service.create(dto); @@ -197,12 +204,60 @@ void shouldReturnExactPetReturnedByRepository() { when(speciesRepository.findById(speciesId)).thenReturn(Optional.of(species)); when(tagRepository.findAllById(anyList())).thenReturn(List.of()); - when(petsMapper.toEntity(any(), any(), anyList())).thenReturn(mappedPet); - when(petRepository.saveAndFlush(mappedPet)).thenReturn(persistedPet); + when(petsMapper.toEntity(any(PetRequestDTO.class), any(Species.class), anyList())) + .thenReturn(mappedPet); + when(petRepository.saveAndFlush(any(Pets.class))).thenReturn(persistedPet); Pets result = service.create(dto); assertThat(result.getId()).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()); + } } } diff --git a/src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java b/src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java new file mode 100644 index 0000000..7a8c249 --- /dev/null +++ b/src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java @@ -0,0 +1,111 @@ +package br.com.db.petcontrol.validation.petstatusforcreation; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +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.mocks.PetsFixture; +import br.com.db.petcontrol.model.enums.PetStatus; +import jakarta.validation.ConstraintValidatorContext; +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; + +@ExtendWith(MockitoExtension.class) +class PetStatusForCreationValidatorTest { + + @Mock private ConstraintValidatorContext context; + @Mock private ConstraintValidatorContext.ConstraintViolationBuilder violationBuilder; + @Mock private ValidPetStatusForCreation annotation; + + private PetStatusForCreationValidator validator; + + @BeforeEach + void setUp() { + validator = new PetStatusForCreationValidator(); + when(annotation.message()).thenReturn("Pet can only be created with status AVAILABLE"); + validator.initialize(annotation); + } + + @Nested + class ValidatePetStatusTests { + + @Test + void shouldReturnTrueWhenStatusIsAvailable() { + PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.AVAILABLE).build(); + + boolean isValid = validator.isValid(dto, context); + + assertThat(isValid).isTrue(); + } + + @Test + void shouldReturnFalseWhenStatusIsInAnalysis() { + PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.IN_ANALYSIS).build(); + when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); + + boolean isValid = validator.isValid(dto, context); + + assertThat(isValid).isFalse(); + } + + @Test + void shouldReturnFalseWhenStatusIsAdopted() { + PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.ADOPTED).build(); + when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); + + boolean isValid = validator.isValid(dto, context); + + assertThat(isValid).isFalse(); + } + + @Test + void shouldReturnTrueWhenDtoIsNull() { + boolean isValid = validator.isValid(null, context); + + assertThat(isValid).isTrue(); + } + + @Test + void shouldReturnTrueWhenStatusIsNull() { + PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(null).build(); + + boolean isValid = validator.isValid(dto, context); + + assertThat(isValid).isTrue(); + } + + @Test + void shouldBuildConstraintViolationWhenStatusIsNotAvailable() { + PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.IN_ANALYSIS).build(); + when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); + + boolean isValid = validator.isValid(dto, context); + + assertThat(isValid).isFalse(); + verify(context).disableDefaultConstraintViolation(); + verify(context) + .buildConstraintViolationWithTemplate( + "Pet can only be created with status AVAILABLE, but got: IN_ANALYSIS"); + verify(violationBuilder).addConstraintViolation(); + } + + @Test + void shouldReturnDetailedMessageWithActualStatus() { + PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.ADOPTED).build(); + when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); + + validator.isValid(dto, context); + + verify(context) + .buildConstraintViolationWithTemplate( + "Pet can only be created with status AVAILABLE, but got: ADOPTED"); + verify(violationBuilder).addConstraintViolation(); + } + } +} From 79710ba1c2b4b5af43fef7ceacad29ee66ea9379 Mon Sep 17 00:00:00 2001 From: Gabriela de Castro Laurindo Date: Tue, 28 Apr 2026 14:21:42 -0300 Subject: [PATCH 5/5] =?UTF-8?q?[PETCONTROL-001]=20refactor:=20realizado=20?= =?UTF-8?q?ajustes=20da=20implementa=C3=A7=C3=A3o?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../petcontrol/controller/PetsController.java | 9 +- .../controller/impl/PetsControllerImpl.java | 4 +- .../petcontrol/dto/request/PetRequestDTO.java | 4 +- .../dto/response/PetResponseDTO.java | 2 +- .../{model => }/enums/PetStatus.java | 2 +- .../java/br/com/db/petcontrol/model/Pets.java | 2 +- .../db/petcontrol/service/PetsService.java | 4 +- .../service/impl/PetsServiceImpl.java | 39 +++--- .../PetStatusForCreationValidator.java | 34 ------ .../ValidPetStatusForCreation.java | 21 ---- .../controller/PetsControllerTest.java | 36 ++---- .../controller/SpeciesControllerTest.java | 4 +- .../controller/TagsControllerTest.java | 4 +- .../integration/PetsIntegrationTest.java | 2 +- .../com/db/petcontrol/mocks/PetsFixture.java | 2 +- .../service/PetsServiceImplTest.java | 47 +++++--- .../PetStatusForCreationValidatorTest.java | 111 ------------------ 17 files changed, 80 insertions(+), 247 deletions(-) rename src/main/java/br/com/db/petcontrol/{model => }/enums/PetStatus.java (60%) delete mode 100644 src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java delete mode 100644 src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java delete mode 100644 src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java diff --git a/src/main/java/br/com/db/petcontrol/controller/PetsController.java b/src/main/java/br/com/db/petcontrol/controller/PetsController.java index af2b330..ff110a8 100644 --- a/src/main/java/br/com/db/petcontrol/controller/PetsController.java +++ b/src/main/java/br/com/db/petcontrol/controller/PetsController.java @@ -27,12 +27,5 @@ public interface PetsController { schema = @Schema(implementation = PetResponseDTO.class))) @ApiResponse(responseCode = "404", description = "Espécie não encontrada") @PostMapping - ResponseEntity create( - @io.swagger.v3.oas.annotations.parameters.RequestBody( - description = "Dados do pet a ser cadastrado", - required = true, - content = @Content(schema = @Schema(implementation = PetRequestDTO.class))) - @Valid - @RequestBody - PetRequestDTO dto); + 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 index 1c77349..91ce7bb 100644 --- a/src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java +++ b/src/main/java/br/com/db/petcontrol/controller/impl/PetsControllerImpl.java @@ -3,7 +3,6 @@ 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.mapper.PetsMapper; import br.com.db.petcontrol.service.PetsService; import lombok.RequiredArgsConstructor; import org.springframework.http.HttpStatus; @@ -15,11 +14,10 @@ public class PetsControllerImpl implements PetsController { private final PetsService petsService; - private final PetsMapper petsMapper; @Override public ResponseEntity create(PetRequestDTO dto) { - PetResponseDTO response = petsMapper.toResponse(petsService.create(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 index 37985d2..ec12377 100644 --- a/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java +++ b/src/main/java/br/com/db/petcontrol/dto/request/PetRequestDTO.java @@ -1,7 +1,6 @@ package br.com.db.petcontrol.dto.request; -import br.com.db.petcontrol.model.enums.PetStatus; -import br.com.db.petcontrol.validation.petstatusforcreation.ValidPetStatusForCreation; +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; @@ -10,7 +9,6 @@ import lombok.Builder; @Builder -@ValidPetStatusForCreation public record PetRequestDTO( @NotBlank @Schema(description = "Nome do pet", example = "Lily") String name, @NotNull 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 index 9934f70..b28fdef 100644 --- a/src/main/java/br/com/db/petcontrol/dto/response/PetResponseDTO.java +++ b/src/main/java/br/com/db/petcontrol/dto/response/PetResponseDTO.java @@ -1,6 +1,6 @@ package br.com.db.petcontrol.dto.response; -import br.com.db.petcontrol.model.enums.PetStatus; +import br.com.db.petcontrol.enums.PetStatus; import io.swagger.v3.oas.annotations.media.Schema; import java.util.List; import java.util.UUID; diff --git a/src/main/java/br/com/db/petcontrol/model/enums/PetStatus.java b/src/main/java/br/com/db/petcontrol/enums/PetStatus.java similarity index 60% rename from src/main/java/br/com/db/petcontrol/model/enums/PetStatus.java rename to src/main/java/br/com/db/petcontrol/enums/PetStatus.java index 738ef95..a9f5237 100644 --- a/src/main/java/br/com/db/petcontrol/model/enums/PetStatus.java +++ b/src/main/java/br/com/db/petcontrol/enums/PetStatus.java @@ -1,4 +1,4 @@ -package br.com.db.petcontrol.model.enums; +package br.com.db.petcontrol.enums; public enum PetStatus { AVAILABLE, diff --git a/src/main/java/br/com/db/petcontrol/model/Pets.java b/src/main/java/br/com/db/petcontrol/model/Pets.java index fbce7b7..112e724 100644 --- a/src/main/java/br/com/db/petcontrol/model/Pets.java +++ b/src/main/java/br/com/db/petcontrol/model/Pets.java @@ -1,6 +1,6 @@ package br.com.db.petcontrol.model; -import br.com.db.petcontrol.model.enums.PetStatus; +import br.com.db.petcontrol.enums.PetStatus; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.EnumType; diff --git a/src/main/java/br/com/db/petcontrol/service/PetsService.java b/src/main/java/br/com/db/petcontrol/service/PetsService.java index 8ee25b5..6707f41 100644 --- a/src/main/java/br/com/db/petcontrol/service/PetsService.java +++ b/src/main/java/br/com/db/petcontrol/service/PetsService.java @@ -1,8 +1,8 @@ package br.com.db.petcontrol.service; import br.com.db.petcontrol.dto.request.PetRequestDTO; -import br.com.db.petcontrol.model.Pets; +import br.com.db.petcontrol.dto.response.PetResponseDTO; public interface PetsService { - Pets create(PetRequestDTO dto); + 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 index c10011d..5f54df2 100644 --- a/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java +++ b/src/main/java/br/com/db/petcontrol/service/impl/PetsServiceImpl.java @@ -1,6 +1,7 @@ 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; @@ -25,7 +26,7 @@ public class PetsServiceImpl implements PetsService { private final TagsRepository tagRepository; private final PetsMapper petsMapper; - public Pets create(PetRequestDTO dto) { + public PetResponseDTO create(PetRequestDTO dto) { List errors = new ArrayList<>(); Species species = speciesRepository.findById(dto.specieId()).orElse(null); @@ -33,25 +34,33 @@ public Pets create(PetRequestDTO dto) { errors.add("Species not found: " + dto.specieId()); } - List tags = List.of(); - if (dto.tagsIds() != null && !dto.tagsIds().isEmpty()) { - List foundTags = tagRepository.findAllById(dto.tagsIds()); - if (foundTags.size() != dto.tagsIds().size()) { - List notFoundIds = - dto.tagsIds().stream() - .filter(id -> foundTags.stream().noneMatch(tag -> tag.getId().equals(id))) - .toList(); - errors.add("Tags not found: " + notFoundIds); - } else { - tags = foundTags; - } - } + List tags = findTagsOrCollectErrors(dto.tagsIds(), errors); if (!errors.isEmpty()) { throw new NotFoundException(errors); } Pets pet = petsMapper.toEntity(dto, species, tags); - return petRepository.saveAndFlush(pet); + 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/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java b/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java deleted file mode 100644 index af7558c..0000000 --- a/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidator.java +++ /dev/null @@ -1,34 +0,0 @@ -package br.com.db.petcontrol.validation.petstatusforcreation; - -import br.com.db.petcontrol.dto.request.PetRequestDTO; -import br.com.db.petcontrol.model.enums.PetStatus; -import jakarta.validation.ConstraintValidator; -import jakarta.validation.ConstraintValidatorContext; - -public class PetStatusForCreationValidator - implements ConstraintValidator { - private String message; - - @Override - public void initialize(ValidPetStatusForCreation annotation) { - this.message = annotation.message(); - } - - @Override - public boolean isValid(PetRequestDTO dto, ConstraintValidatorContext context) { - if (dto == null || dto.status() == null) { - return true; - } - - boolean isValid = dto.status() == PetStatus.AVAILABLE; - - if (!isValid) { - context.disableDefaultConstraintViolation(); - context - .buildConstraintViolationWithTemplate(this.message + ", but got: " + dto.status()) - .addConstraintViolation(); - } - - return isValid; - } -} diff --git a/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java b/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java deleted file mode 100644 index a0b54ef..0000000 --- a/src/main/java/br/com/db/petcontrol/validation/petstatusforcreation/ValidPetStatusForCreation.java +++ /dev/null @@ -1,21 +0,0 @@ -package br.com.db.petcontrol.validation.petstatusforcreation; - -import jakarta.validation.Constraint; -import jakarta.validation.Payload; -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -@Documented -@Constraint(validatedBy = PetStatusForCreationValidator.class) -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.RUNTIME) -public @interface ValidPetStatusForCreation { - String message() default "Pet can only be created with status AVAILABLE"; - - Class[] groups() default {}; - - Class[] payload() default {}; -} diff --git a/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java index 03da095..f20eb17 100644 --- a/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java +++ b/src/test/java/br/com/db/petcontrol/controller/PetsControllerTest.java @@ -12,10 +12,8 @@ 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.mapper.PetsMapper; +import br.com.db.petcontrol.enums.PetStatus; import br.com.db.petcontrol.mocks.PetsFixture; -import br.com.db.petcontrol.model.Pets; -import br.com.db.petcontrol.model.enums.PetStatus; import br.com.db.petcontrol.service.PetsService; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.List; @@ -35,7 +33,6 @@ class PetsControllerTest { @Autowired private ObjectMapper objectMapper; @MockitoBean private PetsService petsService; - @MockitoBean private PetsMapper petsMapper; private static final String PETS_URL = "/pets"; @@ -46,10 +43,8 @@ class CreatePetTests { void shouldCreatePetAndReturnCreatedStatus() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().build(); - Pets createdPet = PetsFixture.builder().build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -63,11 +58,9 @@ void shouldCreatePetAndReturnCreatedStatus() throws Exception { @Test void shouldReturnPetWithCorrectNameInResponse() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().name("Bolinha").build(); - Pets createdPet = PetsFixture.builder().name("Bolinha").build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().name("Bolinha").build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -82,11 +75,9 @@ void shouldReturnPetWithCorrectNameInResponse() throws Exception { void shouldReturnPetWithCorrectIdInResponse() throws Exception { UUID petId = UUID.randomUUID(); PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); - Pets createdPet = PetsFixture.builder().id(petId).build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().id(petId).build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -100,12 +91,10 @@ void shouldReturnPetWithCorrectIdInResponse() throws Exception { @Test void shouldReturnPetWithCorrectStatusInResponse() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().status(PetStatus.AVAILABLE).build(); - Pets createdPet = PetsFixture.builder().status(PetStatus.AVAILABLE).build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().status(PetStatus.AVAILABLE).build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -119,11 +108,9 @@ void shouldReturnPetWithCorrectStatusInResponse() throws Exception { @Test void shouldReturnPetWithCorrectSpeciesInResponse() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); - Pets createdPet = PetsFixture.builder().build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().species("Gato").build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -137,11 +124,9 @@ void shouldReturnPetWithCorrectSpeciesInResponse() throws Exception { @Test void shouldReturnPetWithEmptyTagsInResponse() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().tagsIds(List.of()).build(); - Pets createdPet = PetsFixture.builder().build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().tags(List.of()).build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -153,13 +138,11 @@ void shouldReturnPetWithEmptyTagsInResponse() throws Exception { } @Test - void shouldCallServiceAndMapperWithCorrectArguments() throws Exception { + void shouldCallServiceWithCorrectArguments() throws Exception { PetRequestDTO request = PetsFixture.requestDtoBuilder().build(); - Pets createdPet = PetsFixture.builder().build(); PetResponseDTO response = PetsFixture.responseDtoBuilder().build(); - when(petsService.create(any(PetRequestDTO.class))).thenReturn(createdPet); - when(petsMapper.toResponse(createdPet)).thenReturn(response); + when(petsService.create(any(PetRequestDTO.class))).thenReturn(response); mockMvc .perform( @@ -169,7 +152,6 @@ void shouldCallServiceAndMapperWithCorrectArguments() throws Exception { .andExpect(status().isCreated()); verify(petsService).create(any(PetRequestDTO.class)); - verify(petsMapper).toResponse(createdPet); } } } 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 index 7bc38d9..f2eadcd 100644 --- a/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java +++ b/src/test/java/br/com/db/petcontrol/integration/PetsIntegrationTest.java @@ -5,9 +5,9 @@ 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.model.enums.PetStatus; import br.com.db.petcontrol.repository.PetsRepository; import br.com.db.petcontrol.repository.SpeciesRepository; import br.com.db.petcontrol.repository.TagsRepository; diff --git a/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java b/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java index ec60a45..fddcae1 100644 --- a/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java +++ b/src/test/java/br/com/db/petcontrol/mocks/PetsFixture.java @@ -2,8 +2,8 @@ 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 br.com.db.petcontrol.model.enums.PetStatus; import java.util.List; import java.util.UUID; diff --git a/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java index b0be4da..fb95874 100644 --- a/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java +++ b/src/test/java/br/com/db/petcontrol/service/PetsServiceImplTest.java @@ -9,6 +9,8 @@ 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; @@ -17,7 +19,6 @@ 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.model.enums.PetStatus; import br.com.db.petcontrol.repository.PetsRepository; import br.com.db.petcontrol.repository.SpeciesRepository; import br.com.db.petcontrol.repository.TagsRepository; @@ -59,18 +60,21 @@ void shouldCreatePetSuccessfully() { 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); - Pets result = service.create(dto); + PetResponseDTO result = service.create(dto); assertThat(result).isNotNull(); - assertThat(result.getName()).isEqualTo(expectedPet.getName()); - assertThat(result.getSpecies()).isEqualTo(species); + assertThat(result.name()).isEqualTo(expectedResponse.name()); + assertThat(result.species()).isEqualTo("Cachorro"); } @Test @@ -80,16 +84,18 @@ void shouldReturnPetWithCorrectId() { 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); - Pets result = service.create(dto); + PetResponseDTO result = service.create(dto); - assertThat(result.getId()).isEqualTo(petId); + assertThat(result.id()).isEqualTo(petId); } @Test @@ -119,15 +125,18 @@ void shouldCreatePetWithTags() { 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); - Pets result = service.create(dto); + PetResponseDTO result = service.create(dto); - assertThat(result.getTags()).hasSize(2).containsExactlyInAnyOrder(tag1, tag2); + assertThat(result.tags()).hasSize(2); } @Test @@ -137,16 +146,18 @@ void shouldCreatePetWithEmptyTagsList() { 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); - Pets result = service.create(dto); + PetResponseDTO result = service.create(dto); - assertThat(result.getTags()).isEmpty(); + assertThat(result.tags()).isEmpty(); } @Test @@ -156,16 +167,19 @@ void shouldCreatePetWithCorrectStatus() { 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); - Pets result = service.create(dto); + PetResponseDTO result = service.create(dto); - assertThat(result.getStatus()).isEqualTo(PetStatus.AVAILABLE); + assertThat(result.status()).isEqualTo(PetStatus.AVAILABLE); } @Test @@ -179,11 +193,13 @@ void shouldCallAllRepositoriesWithCorrectArguments() { 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); @@ -191,6 +207,7 @@ void shouldCallAllRepositoriesWithCorrectArguments() { verify(tagRepository).findAllById(tagIds); verify(petsMapper).toEntity(dto, species, tags); verify(petRepository).saveAndFlush(expectedPet); + verify(petsMapper).toResponse(expectedPet); } @Test @@ -201,16 +218,18 @@ void shouldReturnExactPetReturnedByRepository() { 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); - Pets result = service.create(dto); + PetResponseDTO result = service.create(dto); - assertThat(result.getId()).isEqualTo(persistedId); + assertThat(result.id()).isEqualTo(persistedId); } @Test diff --git a/src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java b/src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java deleted file mode 100644 index 7a8c249..0000000 --- a/src/test/java/br/com/db/petcontrol/validation/petstatusforcreation/PetStatusForCreationValidatorTest.java +++ /dev/null @@ -1,111 +0,0 @@ -package br.com.db.petcontrol.validation.petstatusforcreation; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.anyString; -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.mocks.PetsFixture; -import br.com.db.petcontrol.model.enums.PetStatus; -import jakarta.validation.ConstraintValidatorContext; -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; - -@ExtendWith(MockitoExtension.class) -class PetStatusForCreationValidatorTest { - - @Mock private ConstraintValidatorContext context; - @Mock private ConstraintValidatorContext.ConstraintViolationBuilder violationBuilder; - @Mock private ValidPetStatusForCreation annotation; - - private PetStatusForCreationValidator validator; - - @BeforeEach - void setUp() { - validator = new PetStatusForCreationValidator(); - when(annotation.message()).thenReturn("Pet can only be created with status AVAILABLE"); - validator.initialize(annotation); - } - - @Nested - class ValidatePetStatusTests { - - @Test - void shouldReturnTrueWhenStatusIsAvailable() { - PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.AVAILABLE).build(); - - boolean isValid = validator.isValid(dto, context); - - assertThat(isValid).isTrue(); - } - - @Test - void shouldReturnFalseWhenStatusIsInAnalysis() { - PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.IN_ANALYSIS).build(); - when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); - - boolean isValid = validator.isValid(dto, context); - - assertThat(isValid).isFalse(); - } - - @Test - void shouldReturnFalseWhenStatusIsAdopted() { - PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.ADOPTED).build(); - when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); - - boolean isValid = validator.isValid(dto, context); - - assertThat(isValid).isFalse(); - } - - @Test - void shouldReturnTrueWhenDtoIsNull() { - boolean isValid = validator.isValid(null, context); - - assertThat(isValid).isTrue(); - } - - @Test - void shouldReturnTrueWhenStatusIsNull() { - PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(null).build(); - - boolean isValid = validator.isValid(dto, context); - - assertThat(isValid).isTrue(); - } - - @Test - void shouldBuildConstraintViolationWhenStatusIsNotAvailable() { - PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.IN_ANALYSIS).build(); - when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); - - boolean isValid = validator.isValid(dto, context); - - assertThat(isValid).isFalse(); - verify(context).disableDefaultConstraintViolation(); - verify(context) - .buildConstraintViolationWithTemplate( - "Pet can only be created with status AVAILABLE, but got: IN_ANALYSIS"); - verify(violationBuilder).addConstraintViolation(); - } - - @Test - void shouldReturnDetailedMessageWithActualStatus() { - PetRequestDTO dto = PetsFixture.requestDtoBuilder().status(PetStatus.ADOPTED).build(); - when(context.buildConstraintViolationWithTemplate(anyString())).thenReturn(violationBuilder); - - validator.isValid(dto, context); - - verify(context) - .buildConstraintViolationWithTemplate( - "Pet can only be created with status AVAILABLE, but got: ADOPTED"); - verify(violationBuilder).addConstraintViolation(); - } - } -}