diff --git a/backend/src/main/java/com/va2es/backend/repositories/CompanyRepository.java b/backend/src/main/java/com/va2es/backend/repositories/CompanyRepository.java index 53bf357..8f4d824 100644 --- a/backend/src/main/java/com/va2es/backend/repositories/CompanyRepository.java +++ b/backend/src/main/java/com/va2es/backend/repositories/CompanyRepository.java @@ -4,8 +4,10 @@ import java.util.Optional; import org.springframework.data.jpa.repository.JpaRepository; -import com.va2es.backend.models.Company; +import org.springframework.stereotype.Repository; +import com.va2es.backend.models.Company; +@Repository public interface CompanyRepository extends JpaRepository { List findByNomeDaEmpresaIgnoreCase(String nomeDaEmpresa); Optional findByCnpj(String cnpj); diff --git a/backend/src/test/java/com/va2es/backend/company/controller/CompanyControllerTest.java b/backend/src/test/java/com/va2es/backend/company/controller/CompanyControllerTest.java new file mode 100644 index 0000000..9fac2dd --- /dev/null +++ b/backend/src/test/java/com/va2es/backend/company/controller/CompanyControllerTest.java @@ -0,0 +1,176 @@ +package com.va2es.backend.company.controller; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.http.ResponseEntity; + +import com.va2es.backend.controllers.CompanyController; +import com.va2es.backend.dto.CompanyRequestDTO; +import com.va2es.backend.dto.CompanyResponseDTO; +import com.va2es.backend.services.CompanyService; + +import jakarta.persistence.EntityNotFoundException; + +@ExtendWith(MockitoExtension.class) +class CompanyControllerTest { + + @Mock + private CompanyService companyService; + + @InjectMocks + private CompanyController companyController; + + @Test + void testCreateCompany() { + // Arrange: CompanyRequestDTO sem construtor nem setters -> usar campos públicos + CompanyRequestDTO request = new CompanyRequestDTO(); + request.nomeDaEmpresa = "Empresa Teste"; + request.cnpj = "12.345.678/0001-90"; + request.telefone = "9876543210"; + request.areaDeAtuacao = "Tecnologia"; + request.representanteDaEmpresaId = 99L; + + + CompanyResponseDTO mockResponse = mock(CompanyResponseDTO.class); + when(mockResponse.getId()).thenReturn(1L); + when(mockResponse.getNomeDaEmpresa()).thenReturn("Empresa Teste"); + when(mockResponse.getCnpj()).thenReturn("12.345.678/0001-90"); + when(mockResponse.getTelefone()).thenReturn("9876543210"); + when(mockResponse.getAreaDeAtuacao()).thenReturn("Tecnologia"); + when(mockResponse.getRepresentanteDaEmpresaId()).thenReturn(99L); + + when(companyService.create(request)).thenReturn(mockResponse); + + // Act + ResponseEntity response = companyController.cadastrar(request); + + // Assert + assertNotNull(response.getBody()); + assertEquals(1L, response.getBody().getId()); + assertEquals("Empresa Teste", response.getBody().getNomeDaEmpresa()); + assertEquals("12.345.678/0001-90", response.getBody().getCnpj()); + assertEquals("9876543210", response.getBody().getTelefone()); + assertEquals("Tecnologia", response.getBody().getAreaDeAtuacao()); + assertEquals(99L, response.getBody().getRepresentanteDaEmpresaId()); + + verify(companyService, times(1)).create(request); + verifyNoMoreInteractions(companyService); + } + + @Test + void deleteCompanyTest() { + // Arrange + Long companyId = 1L; + + // deletar não retorna nada + doNothing().when(companyService).deleteById(companyId); + // após deletar, buscar deve lançar EntityNotFoundException + when(companyService.findById(companyId)).thenThrow(new EntityNotFoundException("Not found")); + + // Act + companyController.deletar(companyId); + + // Assert: controller deve propagar a exceção ao tentar buscar + assertThrows(EntityNotFoundException.class, () -> companyController.buscarPorId(companyId)); + + verify(companyService, times(1)).deleteById(companyId); + verify(companyService, times(1)).findById(companyId); + verifyNoMoreInteractions(companyService); + } + + @Test + void testFindById_success() { + // Arrange + Long companyId = 1L; + CompanyResponseDTO mockResponse = mock(CompanyResponseDTO.class); + when(mockResponse.getId()).thenReturn(companyId); + when(mockResponse.getNomeDaEmpresa()).thenReturn("Empresa Teste"); + + // Supondo que o service lança exceção quando não encontra + // e retorna o DTO quando encontra: + when(companyService.findById(companyId)).thenReturn(mockResponse); + + // Act + ResponseEntity response = companyController.buscarPorId(companyId); + + // Assert + assertEquals(200, response.getStatusCodeValue()); + assertNotNull(response.getBody()); + assertEquals(companyId, response.getBody().getId()); + assertEquals("Empresa Teste", response.getBody().getNomeDaEmpresa()); + + verify(companyService, times(1)).findById(companyId); + verifyNoMoreInteractions(companyService); + } + + @Test + void testFindById_notFound() { + // Arrange + Long companyId = 99L; + when(companyService.findById(companyId)).thenThrow(new EntityNotFoundException("Not found")); + + // Assert (controller deve propagar a exceção) + assertThrows(EntityNotFoundException.class, () -> companyController.buscarPorId(companyId)); + + verify(companyService, times(1)).findById(companyId); + verifyNoMoreInteractions(companyService); + } + + @Test + void testDeleteCompany_notFound() { + // Arrange + Long companyId = 99L; + doThrow(new EntityNotFoundException("Not found")).when(companyService).deleteById(companyId); + + // Assert (controller deve propagar a exceção) + assertThrows(EntityNotFoundException.class, () -> companyController.deletar(companyId)); + + verify(companyService, times(1)).deleteById(companyId); + verifyNoMoreInteractions(companyService); + } + + @Test + void testUpdateCompany(){ + // Arrange + Long companyId = 1L; + CompanyRequestDTO request = new CompanyRequestDTO(); + request.nomeDaEmpresa = "Empresa Atualizada"; + request.cnpj = "98.765.432/0001-10"; + request.telefone = "1234567890"; + request.areaDeAtuacao = "Finanças"; + request.representanteDaEmpresaId = 100L; + + CompanyResponseDTO mockResponse = mock(CompanyResponseDTO.class); + when(mockResponse.getId()).thenReturn(companyId); + when(mockResponse.getNomeDaEmpresa()).thenReturn("Empresa Atualizada"); + when(mockResponse.getCnpj()).thenReturn("98.765.432/0001-10"); + when(mockResponse.getTelefone()).thenReturn("1234567890"); + when(mockResponse.getAreaDeAtuacao()).thenReturn("Finanças"); + when(mockResponse.getRepresentanteDaEmpresaId()).thenReturn(100L); + + when(companyService.update(companyId, request)).thenReturn(mockResponse); + + // Act + ResponseEntity response = companyController.atualizar(companyId, request); + + // Assert + assertNotNull(response.getBody()); + assertEquals(companyId, response.getBody().getId()); + assertEquals("Empresa Atualizada", response.getBody().getNomeDaEmpresa()); + assertEquals("98.765.432/0001-10", response.getBody().getCnpj()); + assertEquals("1234567890", response.getBody().getTelefone()); + assertEquals("Finanças", response.getBody().getAreaDeAtuacao()); + assertEquals(100L, response.getBody().getRepresentanteDaEmpresaId()); + + verify(companyService, times(1)).update(companyId, request); + verifyNoMoreInteractions(companyService); + } + + +} diff --git a/backend/src/test/java/com/va2es/backend/company/service/CompanyServiceTest.java b/backend/src/test/java/com/va2es/backend/company/service/CompanyServiceTest.java index eeb6a9c..d49ffad 100644 --- a/backend/src/test/java/com/va2es/backend/company/service/CompanyServiceTest.java +++ b/backend/src/test/java/com/va2es/backend/company/service/CompanyServiceTest.java @@ -2,7 +2,6 @@ import static org.junit.jupiter.api.Assertions.*; -import java.util.List; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; diff --git a/backend/src/test/java/com/va2es/backend/student/service/StudentServiceTest.java b/backend/src/test/java/com/va2es/backend/student/service/StudentServiceTest.java index 426e302..7ba9837 100644 --- a/backend/src/test/java/com/va2es/backend/student/service/StudentServiceTest.java +++ b/backend/src/test/java/com/va2es/backend/student/service/StudentServiceTest.java @@ -38,30 +38,53 @@ public class StudentServiceTest { private UserRepository userRepository; @Autowired - private StudentService studentService; - - + private StudentService studentService; + + @Test + public void deveCriarEstudanteComSucesso() { + // cria e salva o usuário + User user = new User( + "user@test.com", + "password123", + UserRole.ADMIN, + "João de Teste" + ); + User savedUser = userRepository.save(user); + + // cria DTO do estudante + StudentRequestDTO dto = new StudentRequestDTO(); + dto.fullName = "João Silva"; + dto.birthDate = LocalDate.of(2000, 1, 1); + dto.cpf = "12345678900"; + dto.phone = "9999999999"; + dto.course = "Ciência da Computação"; + dto.currentPeriod = 4; + dto.academicSummary = "Bom aluno"; + dto.userId = savedUser.getId(); + + // executa service + StudentResponseDTO response = studentService.create(dto); + + // validações + assertNotNull(response); + assertEquals("João Silva", response.fullName); + assertEquals("12345678900", response.cpf); + + // verifica persistência no banco + assertTrue(studentRepository.existsByCpf("12345678900")); + } + @Test - public void deveCriarEstudanteComSucesso() { - // cria e salva o usuário - User user = new User( - "user@test.com", - "password123", - UserRole.ADMIN, - "João de Teste" - ); - User savedUser = userRepository.save(user); - - // cria DTO do estudante - USANDO SETTERS + public void deveLancarExcecaoQuandoUsuarioNaoExistir() { StudentRequestDTO dto = new StudentRequestDTO(); - dto.setFullName("João Silva"); - dto.setBirthDate(LocalDate.of(2000, 1, 1)); - dto.setCpf("12345678900"); - dto.setPhone("999999999"); - dto.setCourse("Ciência da Computação"); - dto.setCurrentPeriod(4); - dto.setAcademicSummary("Bom aluno"); - dto.setUserId(savedUser.getId()); + dto.fullName = "Carlos Souza"; + dto.birthDate = LocalDate.of(2002, 3, 3); + dto.cpf = "98765432100"; + dto.phone = "6666666668"; + dto.course = "Medicina"; + dto.currentPeriod = 1; + dto.academicSummary = "Resumo"; + dto.userId = 999L; // ID inexistente // executa service StudentResponseDTO response = studentService.create(dto); @@ -102,16 +125,16 @@ public void deletarEstudanteComSucesso() { ); User savedUser = userRepository.save(user); - // cria DTO do estudante - StudentRequestDTO dto = new StudentRequestDTO(); - dto.setFullName("João Silva"); - dto.setBirthDate(LocalDate.of(2000, 1, 1)); - dto.setCpf("12345678880"); - dto.setPhone("999999999"); - dto.setCourse("Ciência da Computação"); - dto.setCurrentPeriod(4); - dto.setAcademicSummary("Bom aluno"); - dto.setUserId(savedUser.getId()); + // cria DTO do estudante + StudentRequestDTO dto = new StudentRequestDTO(); + dto.fullName = "João Silva"; + dto.birthDate = LocalDate.of(2000, 1, 1); + dto.cpf = "12345678880"; + dto.phone = "9999999999"; + dto.course = "Ciência da Computação"; + dto.currentPeriod = 4; + dto.academicSummary = "Bom aluno"; + dto.userId = savedUser.getId(); StudentResponseDTO response = studentService.create(dto); @@ -137,39 +160,40 @@ public void deletarEstudanteComSucesso() { @Test public void pegarEstudantePorIdComSucesso() { - // cria e salva o usuário - User user = new User( - "user@test6.com", - "password123", - UserRole.ADMIN, - "João de Teste" - ); - User savedUser = userRepository.save(user); - - // cria DTO do estudante - StudentRequestDTO dto = new StudentRequestDTO(); - dto.setFullName("João Silva"); - dto.setBirthDate(LocalDate.of(2000, 1, 1)); - dto.setCpf("12345600880"); - dto.setPhone("999999999"); - dto.setCourse("Ciência da Computação"); - dto.setCurrentPeriod(4); - dto.setAcademicSummary("Bom aluno"); - dto.setUserId(savedUser.getId()); - - StudentResponseDTO response = studentService.create(dto); - - assertNotNull(response); - assertEquals("João Silva", response.getFullName()); - - // busca o estudante por ID - StudentResponseDTO found = studentService.findById(response.getId()); - assertNotNull(found); - assertEquals(response.getId(), found.getId()); - assertEquals(response.getFullName(), found.getFullName()); - assertEquals(response.getCpf(), found.getCpf()); + // cria e salva o usuário + User user = new User( + "user@test6.com", + "password123", + UserRole.ADMIN, + "João de Teste" + ); + User savedUser = userRepository.save(user); + + // cria DTO do estudante + StudentRequestDTO dto = new StudentRequestDTO(); + dto.fullName = "João Silva"; + dto.birthDate = LocalDate.of(2000, 1, 1); + dto.cpf = "12345600880"; + dto.phone = "9999999999"; + dto.course = "Ciência da Computação"; + dto.currentPeriod = 4; + dto.academicSummary = "Bom aluno"; + dto.userId = savedUser.getId(); + + StudentResponseDTO response = studentService.create(dto); + + assertNotNull(response); + assertEquals("João Silva", response.fullName); + + // busca o estudante por ID + StudentResponseDTO found = studentService.findById(response.id); + assertNotNull(found); + assertEquals(response.id, found.id); + assertEquals(response.fullName, found.fullName); + assertEquals(response.cpf, found.cpf); } + @Test // <<-- Faltava esta anotação public void atualizarEstudanteComSucesso() { @@ -184,14 +208,14 @@ public void atualizarEstudanteComSucesso() { // cria DTO do estudante StudentRequestDTO dto = new StudentRequestDTO(); - dto.setFullName("João Silva"); - dto.setBirthDate(LocalDate.of(2000, 1, 1)); - dto.setCpf("12345678955"); - dto.setPhone("999999999"); - dto.setCourse("Ciência da Computação"); - dto.setCurrentPeriod(4); - dto.setAcademicSummary("Bom aluno"); - dto.setUserId(savedUser.getId()); + dto.fullName = "João Silva"; + dto.birthDate = LocalDate.of(2000, 1, 1); + dto.cpf = "12345678955"; + dto.phone = "9999999990"; + dto.course = "Ciência da Computação"; + dto.currentPeriod = 4; + dto.academicSummary = "Bom aluno"; + dto.userId = savedUser.getId(); StudentResponseDTO response = studentService.create(dto); @@ -213,38 +237,39 @@ public void atualizarEstudanteComSucesso() { assertEquals("Letras", updatedResponse.getCourse()); } - @Test - public void naoDevePermitirDeletarEstudanteSemAutenticacao() { - // cria e salva o usuário - User user = new User( - "user@test3.com", - "password123", - UserRole.ADMIN, - "João de Teste" - ); - User savedUser = userRepository.save(user); - - // cria DTO do estudante - StudentRequestDTO dto = new StudentRequestDTO(); - dto.setFullName("Maria Silva"); - dto.setBirthDate(LocalDate.of(2001, 2, 2)); - dto.setCpf("12312312399"); - dto.setPhone("999888777"); - dto.setCourse("Engenharia"); - dto.setCurrentPeriod(3); - dto.setAcademicSummary("Resumo"); - dto.setUserId(savedUser.getId()); - - StudentResponseDTO response = studentService.create(dto); - - // NÃO setamos o SecurityContextHolder aqui → simula usuário não autenticado - - // espera AccessDeniedException - assertThrows( - org.springframework.security.access.AccessDeniedException.class, - () -> studentService.delete(response.getId()) - ); - } - +@Test +public void naoDevePermitirDeletarEstudanteSemAutenticacao() { + // cria e salva o usuário + User user = new User( + "user@test3.com", + "password123", + UserRole.ADMIN, + "João de Teste" + ); + User savedUser = userRepository.save(user); + + // cria DTO do estudante + StudentRequestDTO dto = new StudentRequestDTO(); + dto.fullName = "Maria Silva"; + dto.birthDate = LocalDate.of(2001, 2, 2); + dto.cpf = "12312312399"; + dto.phone = "9998887077"; + dto.course = "Engenharia"; + dto.currentPeriod = 3; + dto.academicSummary = "Resumo"; + dto.userId = savedUser.getId(); + + StudentResponseDTO response = studentService.create(dto); + + // 🔑 NÃO setamos o SecurityContextHolder aqui → simula usuário não autenticado + + // espera AccessDeniedException + assertThrows( + org.springframework.security.access.AccessDeniedException.class, + () -> studentService.delete(response.id) + ); +} + + +} -} \ No newline at end of file diff --git a/backend/src/test/java/com/va2es/backend/vacancy/Controller/VacancyControllerTest.java b/backend/src/test/java/com/va2es/backend/vacancy/Controller/VacancyControllerTest.java new file mode 100644 index 0000000..2177d8e --- /dev/null +++ b/backend/src/test/java/com/va2es/backend/vacancy/Controller/VacancyControllerTest.java @@ -0,0 +1,5 @@ +package com.va2es.backend.vacancy.Controller; + +public class VacancyControllerTest { + +} diff --git a/backend/src/test/java/com/va2es/backend/vacancy/service/VacancyServiceTest.java b/backend/src/test/java/com/va2es/backend/vacancy/service/VacancyServiceTest.java new file mode 100644 index 0000000..6b26eeb --- /dev/null +++ b/backend/src/test/java/com/va2es/backend/vacancy/service/VacancyServiceTest.java @@ -0,0 +1,104 @@ +package com.va2es.backend.vacancy.service; + +import com.va2es.backend.dto.VacancyRequestDTO; +import com.va2es.backend.dto.VacancyResponseDTO; +import com.va2es.backend.models.Company; +import com.va2es.backend.models.Vacancy; +import com.va2es.backend.models.enums.VacancyType; +import com.va2es.backend.repositories.CompanyRepository; +import com.va2es.backend.repositories.VacancyRepository; +import com.va2es.backend.services.VacancyService; + +import jakarta.persistence.EntityNotFoundException; + +import org.checkerframework.checker.units.qual.s; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; + +import java.time.LocalDate; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.*; + +class VacancyServiceTest { + + @Mock + private CompanyRepository companyRepository; + + @Mock + private VacancyRepository vacancyRepository; + + @InjectMocks + private VacancyService vacancyService; + @BeforeEach + void setUp() { + MockitoAnnotations.openMocks(this); + vacancyService = spy(vacancyService); + doNothing().when(vacancyService).checkPermission(anyLong()); + } + + @Test + void createVacancy_ShouldThrowException_WhenCompanyNotFound() { + // given + VacancyRequestDTO request = new VacancyRequestDTO(); + request.setCompanyId(99L); + + when(companyRepository.findById(99L)).thenReturn(Optional.empty()); + + // when / then + EntityNotFoundException ex = assertThrows(EntityNotFoundException.class, + () -> vacancyService.createVacancy(request)); + + assertEquals("Empresa não encontrada", ex.getMessage()); + verify(companyRepository, times(1)).findById(99L); + verifyNoInteractions(vacancyRepository); + } + + + @Test + void deleteVacancy_ShouldThrowException_WhenVacancyNotFound() { + // given + Long vacancyId = 99L; + when(vacancyRepository.findById(vacancyId)).thenReturn(Optional.empty()); + + // when / then + EntityNotFoundException ex = assertThrows(EntityNotFoundException.class, + () -> vacancyService.delete(vacancyId)); + + assertEquals("Vaga não encontrada", ex.getMessage()); + verify(vacancyRepository, times(1)).findById(vacancyId); + verify(vacancyRepository, never()).delete(any()); + } + + @Test + void deleteVacancy_ShouldDelete_WhenVacancyExists() { + // given + Long vacancyId = 1L; + Company empresa = new Company(); + empresa.setId(10L); + + Vacancy vaga = new Vacancy(); + vaga.setId(vacancyId); + vaga.setCompany(empresa); + + when(vacancyRepository.findById(vacancyId)).thenReturn(Optional.of(vaga)); + + // spy to bypass permission check if necessary + // vacancyService = spy(vacancyService); + // doNothing().when(vacancyService).checkPermission(anyLong()); + + // when + vacancyService.delete(vacancyId); + + // then + verify(vacancyRepository, times(1)).findById(vacancyId); + verify(vacancyRepository, times(1)).delete(vaga); + } +}