From 3b538f8e5696fe0b8a01c8a9209016540515955b Mon Sep 17 00:00:00 2001 From: mohammad Date: Fri, 8 Nov 2024 16:57:33 +0100 Subject: [PATCH 1/4] test: "Adding tests for EmployeeController and ProjectController" --- .../api/EmployeeControllerTest.java | 57 +++++ .../api/ProjectControllerTest.java | 199 ++++++++++++++++++ 2 files changed, 256 insertions(+) create mode 100644 src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java create mode 100644 src/test/java/com/maradona/backend/controllers/api/ProjectControllerTest.java diff --git a/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java b/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java new file mode 100644 index 0000000..15b3048 --- /dev/null +++ b/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java @@ -0,0 +1,57 @@ +package com.maradona.backend.controllers.api; + +import com.maradona.backend.controllers.api.EmployeeController; +import com.maradona.backend.entities.Employee; +import com.maradona.backend.services.EmployeeService; +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.web.servlet.MockMvc; + +import java.time.LocalTime; +import java.util.Optional; + +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; + +@WebMvcTest(EmployeeController.class) +public class EmployeeControllerTest { + + @Autowired + private MockMvc mockMvc; + + @MockBean + private EmployeeService employeeService; + + @Test + public void testGetEmployeeById() throws Exception { + // Arrange: Mock an employee + Employee employee = new Employee(); + employee.setId(1L); + employee.setEmployeeNr(123); + employee.setFirstName("John"); + employee.setLastName("Doe"); + employee.setDStart(LocalTime.of(9, 0)); + employee.setDEnd(LocalTime.of(17, 0)); + + // Assuming FormOfAddress and EmployeeSecondarySkill are also set up if needed for your test. + + when(employeeService.getEmployeeById(1L)).thenReturn(Optional.of(employee)); + + // Act & Assert: Send GET request and expect a 200 OK status and JSON response + mockMvc.perform(get("/api/employee") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(1)) + .andExpect(jsonPath("$.employeeNr").value(123)) + .andExpect(jsonPath("$.firstName").value("John")) + .andExpect(jsonPath("$.lastName").value("Doe")) + .andExpect(jsonPath("$.dStart").value("09:00:00")) + .andExpect(jsonPath("$.dEnd").value("17:00:00")); + } +} diff --git a/src/test/java/com/maradona/backend/controllers/api/ProjectControllerTest.java b/src/test/java/com/maradona/backend/controllers/api/ProjectControllerTest.java new file mode 100644 index 0000000..8cc4f99 --- /dev/null +++ b/src/test/java/com/maradona/backend/controllers/api/ProjectControllerTest.java @@ -0,0 +1,199 @@ +package com.maradona.backend.controllers.api; + +import com.maradona.backend.controllers.api.ProjectController; +import com.maradona.backend.entities.Project; +import com.maradona.backend.services.ProjectService; +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.web.servlet.MockMvc; + +import java.time.LocalDate; +import java.util.Arrays; +import java.util.Optional; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; + +@WebMvcTest(ProjectController.class) +public class ProjectControllerTest { + // MockMvc to simulate HTTP requests to the controller + @Autowired + private MockMvc mockMvc; + + // Mocked ProjectService to simulate service calls + @MockBean + private ProjectService projectService; + + @Test + public void testGetProjectById() throws Exception { + //Arrange: Mock an project + Project project = new Project(); + project.setId(1L); + project.setName("Skillmanagementsystem erstellen"); + project.setStartDate(LocalDate.of(2024, 11,8)); + project.setEndDate(LocalDate.of(2024, 11,20)); + project.setWorkload(12); + project.setDescription("Skillmanagementsystem erstellen für die Firma"); + + //Define the behavior of the mocked ProjectService: return the project when ID 1 is requested + when(projectService.getProjectById(1L)).thenReturn(Optional.of(project)); + + //Act & Assert: Send GET request an expect a 200 OK status and JSON response + //GET /api/project/ + mockMvc.perform(get("/api/project") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(1)) + .andExpect(jsonPath("$.name").value("Skillmanagementsystem erstellen")) + .andExpect(jsonPath("$.startDate").value("2024-11-08")) + .andExpect(jsonPath("$.endDate").value("2024-11-20")) + .andExpect(jsonPath("$.workload").value(12)) + .andExpect(jsonPath("$.description").value("Skillmanagementsystem erstellen für die Firma")); + } + + @Test + public void testGetAllProjects() throws Exception { + //Arrange: Creat a list of mock projects + Project project = new Project(); + project.setId(1L); + project.setName("Skillmanagementsystem erstellen"); + project.setStartDate(LocalDate.of(2024, 11,8)); + project.setEndDate(LocalDate.of(2024, 11,20)); + project.setWorkload(12); + project.setDescription("Skillmanagementsystem erstellen für die Firma"); + + Project project2 = new Project(); + project2.setId(2L); + project2.setName("EAFC 25"); + project2.setStartDate(LocalDate.of(2024, 11,20)); + project2.setEndDate(LocalDate.of(2024, 11,30)); + project2.setWorkload(2); + project2.setDescription("Entwicklung von EAFC 25 für neues Spaß erlebnis"); + + //Define the behavior of the mocked ProjectService: return a list of projects when requested + when(projectService.getAllProjects()).thenReturn(Arrays.asList(project, project2)); + + //Act & Assert: Send GET request an expect a 200 Ok status and JSON response with the list of projects + mockMvc.perform(get("/api/project/all") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].id").value(1)) + .andExpect(jsonPath("$[0].name").value("Skillmanagementsystem erstellen")) + .andExpect(jsonPath("$[0].startDate").value("2024-11-08")) + .andExpect(jsonPath("$[0].endDate").value("2024-11-20")) + .andExpect(jsonPath("$[0].workload").value(12)) + .andExpect(jsonPath("$[0].description").value("Skillmanagementsystem erstellen für die Firma")) + .andExpect(jsonPath("$[1].id").value(2)) + .andExpect(jsonPath("$[1].name").value("EAFC 25")) + .andExpect(jsonPath("$[1].startDate").value("2024-11-20")) + .andExpect(jsonPath("$[1].endDate").value("2024-11-30")) + .andExpect(jsonPath("$[1].workload").value(2)) + .andExpect(jsonPath("$[1].description").value("Entwicklung von EAFC 25 für neues Spaß erlebnis")); + } + + @Test + public void testGetProjectsByUserId() throws Exception { + // Arrange: Mock projects for a specific user + Project project1 = new Project(); + project1.setId(1L); + project1.setName("Skill Management System"); + project1.setStartDate(LocalDate.of(2024, 11, 8)); + project1.setEndDate(LocalDate.of(2024, 11, 20)); + project1.setWorkload(12); + project1.setDescription("Create a skill management system for the company"); + + Project project2 = new Project(); + project2.setId(2L); + project2.setName("Project Management Tool"); + project2.setStartDate(LocalDate.of(2024, 12, 1)); + project2.setEndDate(LocalDate.of(2024, 12, 15)); + project2.setWorkload(10); + project2.setDescription("Develop a project management tool"); + + Long userId = 123L; + + // Mock the ProjectService to return projects for a specific user + when(projectService.getProjectsByUserId(userId)).thenReturn(Arrays.asList(project1, project2)); + + // Act & Assert: Send GET request and expect a 200 OK status with the correct JSON response + mockMvc.perform(get("/api/project/from-user") + .param("userId", String.valueOf(userId)) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].id").value(1)) + .andExpect(jsonPath("$[0].name").value("Skill Management System")) + .andExpect(jsonPath("$[1].id").value(2)) + .andExpect(jsonPath("$[1].name").value("Project Management Tool")); + } + + @Test + public void testCreateProject() throws Exception { + // Arrange: Create a new project and set all required fields + Project savedProject = new Project(); + savedProject.setId(1L); // ID setzen + savedProject.setName("New Project"); + savedProject.setStartDate(LocalDate.of(2024, 11, 10)); + savedProject.setEndDate(LocalDate.of(2024, 12, 10)); + savedProject.setWorkload(15); + savedProject.setDescription("A new project for testing"); + + // Mocking the saveProject method to return this specific project + when(projectService.saveProject(any(Project.class))).thenReturn(savedProject); + + // Act & Assert: Send POST request and check for 201 Created with JSON response + mockMvc.perform(post("/api/project") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"name\":\"New Project\",\"startDate\":\"2024-11-10\",\"endDate\":\"2024-12-10\",\"workload\":15,\"description\":\"A new project for testing\"}")) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.id").value(1)) // Ensure the response JSON contains id = 1 + .andExpect(jsonPath("$.name").value("New Project")) + .andExpect(jsonPath("$.workload").value(15)) + .andExpect(jsonPath("$.description").value("A new project for testing")); + } + + @Test + public void testUpdateProject() throws Exception { + // Arrange: Create an existing project + Project project = new Project(); + project.setId(1L); + project.setName("Updated Project"); + project.setStartDate(LocalDate.of(2024, 11, 10)); + project.setEndDate(LocalDate.of(2024, 12, 10)); + project.setWorkload(20); + project.setDescription("An updated project description"); + + // Mock the ProjectService to return the updated project + when(projectService.saveProject(project)).thenReturn(project); + + // Act & Assert: Send PUT request and expect a 200 OK status with the updated project as JSON response + mockMvc.perform(put("/api/project") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"id\":1,\"name\":\"Updated Project\",\"startDate\":\"2024-11-10\",\"endDate\":\"2024-12-10\",\"workload\":20,\"description\":\"An updated project description\"}")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(1)) + .andExpect(jsonPath("$.name").value("Updated Project")) + .andExpect(jsonPath("$.workload").value(20)) + .andExpect(jsonPath("$.description").value("An updated project description")); + } + + @Test + public void testDeleteProject() throws Exception { + // Arrange: Define the ID of the project to delete + Long projectId = 1L; + + // No need to mock the delete method as it returns void, we just ensure no exception is thrown + + // Act & Assert: Send DELETE request and expect a 204 No Content status + mockMvc.perform(delete("/api/project") + .param("id", String.valueOf(projectId)) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isNoContent()); + } +} From c97b33fdc39e5988356bff915a9551b9cabff708 Mon Sep 17 00:00:00 2001 From: 3001962 <3001962@stud.hs-mannheim.de> Date: Sat, 9 Nov 2024 14:51:18 +0100 Subject: [PATCH 2/4] test: Add unit tests for primaryskillcontrolle endpoints with mock validation --- .../api/PrimarySkillControllerTest.java | 140 ++++++++++++++++++ 1 file changed, 140 insertions(+) create mode 100644 src/test/java/com/maradona/backend/controllers/api/PrimarySkillControllerTest.java diff --git a/src/test/java/com/maradona/backend/controllers/api/PrimarySkillControllerTest.java b/src/test/java/com/maradona/backend/controllers/api/PrimarySkillControllerTest.java new file mode 100644 index 0000000..70f5e1a --- /dev/null +++ b/src/test/java/com/maradona/backend/controllers/api/PrimarySkillControllerTest.java @@ -0,0 +1,140 @@ +package com.maradona.backend.controllers.api; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.maradona.backend.entities.PrimarySkill; +import com.maradona.backend.services.PrimarySkillService; +import com.maradona.backend.services.SecondarySkillService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.*; +import org.springframework.http.MediaType; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.result.MockMvcResultMatchers; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.util.List; +import java.util.Optional; + +import static org.mockito.ArgumentMatchers.any; + +public class PrimarySkillControllerTest { + + private MockMvc mockMvc; + + @Mock + private PrimarySkillService primarySkillService; + + @Mock + private SecondarySkillService secondarySkillService; + + @InjectMocks + private PrimarySkillController primarySkillController; + + private PrimarySkill primarySkill; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + mockMvc = MockMvcBuilders.standaloneSetup(primarySkillController).build(); + + // Initialisieren eines Beispiels für PrimarySkill + primarySkill = new PrimarySkill(); + primarySkill.setPsid(1L); + primarySkill.setDescription("Test Primary Skill"); + } + + @Test + public void testGetPrimarySkillById_Success() throws Exception { + // Mock das Service, um ein PrimarySkill zu liefern + Mockito.when(primarySkillService.getPrimarySkillById(1L)).thenReturn(Optional.of(primarySkill)); + + // Führe die GET-Anfrage aus + mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill") + .param("id", "1")) + .andExpect(MockMvcResultMatchers.status().isOk()) + .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1)) + .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); + + // Verifiziere, dass der Service aufgerufen wurde + Mockito.verify(primarySkillService, Mockito.times(1)).getPrimarySkillById(1L); + } + + @Test + public void testGetAllPrimarySkills() throws Exception { + // Mock das Service, um eine Liste von PrimarySkills zu liefern + Mockito.when(primarySkillService.getAllPrimarySkills()).thenReturn(List.of(primarySkill)); + + // Führe die GET-Anfrage aus + mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill/all")) + .andExpect(MockMvcResultMatchers.status().isOk()) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].psid").value(1)) + .andExpect(MockMvcResultMatchers.jsonPath("$[0].description").value("Test Primary Skill")); + + // Verifiziere, dass der Service aufgerufen wurde + Mockito.verify(primarySkillService, Mockito.times(1)).getAllPrimarySkills(); + } + + @Test + public void testCreatePrimarySkill() throws Exception { + // Mock das Service, um das PrimarySkill zu speichern + Mockito.when(primarySkillService.savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class))).thenReturn(primarySkill); + + // Führe die POST-Anfrage aus + mockMvc.perform(MockMvcRequestBuilders.post("/api/primary-skill") + .contentType(MediaType.APPLICATION_JSON) + .content(new ObjectMapper().writeValueAsString(primarySkill))) // Hier wird das PrimarySkill als JSON übermittelt + .andExpect(MockMvcResultMatchers.status().isCreated()) // Erwartet den Statuscode 201 Created + .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1)) // Überprüft das psid in der Antwort + .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); // Überprüft die Beschreibung + + // Verifiziere, dass der Service aufgerufen wurde + Mockito.verify(primarySkillService, Mockito.times(1)).savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class)); + } + + + @Test + public void testUpdatePrimarySkill() throws Exception { + // Mock das Service, um das PrimarySkill zu speichern + Mockito.when(primarySkillService.savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class))).thenReturn(primarySkill); + + // Führe die PUT-Anfrage aus + mockMvc.perform(MockMvcRequestBuilders.put("/api/primary-skill") + .contentType(MediaType.APPLICATION_JSON) + .content(new ObjectMapper().writeValueAsString(primarySkill))) + .andExpect(MockMvcResultMatchers.status().isOk()) + .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1)) + .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); + + // Verifiziere, dass der Service aufgerufen wurde + Mockito.verify(primarySkillService, Mockito.times(1)).savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class)); + } + + @Test + public void testDeletePrimarySkill_Success() throws Exception { + // Mock das Service, um das PrimarySkill zu liefern + Mockito.when(primarySkillService.getPrimarySkillById(1L)).thenReturn(Optional.of(primarySkill)); + + // Führe die DELETE-Anfrage aus + mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill") + .param("id", "1")) + .andExpect(MockMvcResultMatchers.status().isNoContent()); + + // Verifiziere, dass der Service aufgerufen wurde + Mockito.verify(primarySkillService, Mockito.times(1)).deletePrimarySkill(1L); + } + + @Test + public void testDeletePrimarySkill_NotFound() throws Exception { + // Mock das Service, um das PrimarySkill nicht zu finden + Mockito.when(primarySkillService.getPrimarySkillById(1L)).thenReturn(Optional.empty()); + + // Führe die DELETE-Anfrage aus + mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill") + .param("id", "1")) + .andExpect(MockMvcResultMatchers.status().isNotFound()); + + // Verifiziere, dass der Service nicht aufgerufen wurde + Mockito.verify(primarySkillService, Mockito.never()).deletePrimarySkill(1L); + } +} From d16c98ad04786b880db6b21034c73cdfab7d90d0 Mon Sep 17 00:00:00 2001 From: 3001291 <3001291@stud.hs-mannheim.de> Date: Sat, 9 Nov 2024 15:42:09 +0100 Subject: [PATCH 3/4] test: Add FormOfAdressControllerTest.java and SecondarySkillControllerTest.java --- .../api/FormOfAdressControllerTest.java | 131 ++++++++++++++++++ .../api/SecondarySkillControllerTest.java | 130 +++++++++++++++++ 2 files changed, 261 insertions(+) create mode 100644 src/test/java/com/maradona/backend/controllers/api/FormOfAdressControllerTest.java create mode 100644 src/test/java/com/maradona/backend/controllers/api/SecondarySkillControllerTest.java diff --git a/src/test/java/com/maradona/backend/controllers/api/FormOfAdressControllerTest.java b/src/test/java/com/maradona/backend/controllers/api/FormOfAdressControllerTest.java new file mode 100644 index 0000000..e7caa7d --- /dev/null +++ b/src/test/java/com/maradona/backend/controllers/api/FormOfAdressControllerTest.java @@ -0,0 +1,131 @@ +package com.maradona.backend.controllers.api; + +import com.maradona.backend.entities.FormOfAddress; +import com.maradona.backend.services.FormOfAddressService; +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.web.servlet.MockMvc; + +import java.util.Optional; +import java.util.Arrays; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; + +@WebMvcTest(FormOfAdressController.class) +public class FormOfAdressControllerTest { + + @Autowired + private MockMvc mockMvc; + + @MockBean + private FormOfAddressService formOfAdressService; + + @Test + public void testGetFormOfAdressById() throws Exception { + FormOfAddress formOfAddress = new FormOfAddress(); + formOfAddress.setId(1L); + formOfAddress.setDescription("Mr."); + + when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.of(formOfAddress)); + + mockMvc.perform(get("/api/form-of-adress") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(1)) + .andExpect(jsonPath("$.description").value("Mr.")); + } + + @Test + public void testGetAllFormOfAdresses() throws Exception { + FormOfAddress form1 = new FormOfAddress(); + form1.setId(1L); + form1.setDescription("Mr."); + + FormOfAddress form2 = new FormOfAddress(); + form2.setId(2L); + form2.setDescription("Ms."); + + when(formOfAdressService.getAllFormOfAddresses()).thenReturn(Arrays.asList(form1, form2)); + + mockMvc.perform(get("/api/form-of-adress/all") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].id").value(1)) + .andExpect(jsonPath("$[0].description").value("Mr.")) + .andExpect(jsonPath("$[1].id").value(2)) + .andExpect(jsonPath("$[1].description").value("Ms.")); + } + + @Test + public void testCreateFormOfAdress() throws Exception { + FormOfAddress formOfAddress = new FormOfAddress(); + formOfAddress.setId(1L); + formOfAddress.setDescription("Dr."); + + when(formOfAdressService.saveFormOfAddress(any(FormOfAddress.class))).thenReturn(formOfAddress); + + mockMvc.perform(post("/api/form-of-adress") + .contentType(MediaType.APPLICATION_JSON) + .content("\"Dr.\"")) + .andExpect(status().isOk()); + } + + @Test + public void testUpdateFormOfAdress() throws Exception { + FormOfAddress existingForm = new FormOfAddress(); + existingForm.setId(1L); + existingForm.setDescription("Mr."); + + when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.of(existingForm)); + + mockMvc.perform(put("/api/form-of-adress") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON) + .content("\"Prof.\"")) + .andExpect(status().isOk()); + } + + @Test + public void testUpdateFormOfAdressNotFound() throws Exception { + when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.empty()); + + mockMvc.perform(put("/api/form-of-adress") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON) + .content("\"Prof.\"")) + .andExpect(status().isNotFound()); + } + + @Test + public void testDeleteFormOfAdress() throws Exception { + FormOfAddress formOfAddress = new FormOfAddress(); + formOfAddress.setId(1L); + formOfAddress.setDescription("Mr."); + + when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.of(formOfAddress)); + + mockMvc.perform(delete("/api/form-of-adress") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()); + } + + @Test + public void testDeleteFormOfAdressNotFound() throws Exception { + when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.empty()); + + mockMvc.perform(delete("/api/form-of-adress") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isNotFound()); + } +} \ No newline at end of file diff --git a/src/test/java/com/maradona/backend/controllers/api/SecondarySkillControllerTest.java b/src/test/java/com/maradona/backend/controllers/api/SecondarySkillControllerTest.java new file mode 100644 index 0000000..f4198b8 --- /dev/null +++ b/src/test/java/com/maradona/backend/controllers/api/SecondarySkillControllerTest.java @@ -0,0 +1,130 @@ +package com.maradona.backend.controllers.api; + +import com.maradona.backend.entities.SecondarySkill; +import com.maradona.backend.services.SecondarySkillService; +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.web.servlet.MockMvc; + +import java.util.Arrays; +import java.util.Optional; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; + +@WebMvcTest(SecondarySkillController.class) +public class SecondarySkillControllerTest { + + @Autowired + private MockMvc mockMvc; + + @MockBean + private SecondarySkillService secondarySkillService; + + @Test + public void testGetSecondarySkillById() throws Exception { + SecondarySkill skill = new SecondarySkill(); + skill.setSsid(1L); + skill.setDescription("Java Programming"); + + when(secondarySkillService.getSecondarySkillById(1L)).thenReturn(Optional.of(skill)); + + mockMvc.perform(get("/api/secondary-skill") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.ssid").value(1)) + .andExpect(jsonPath("$.description").value("Java Programming")); + } + + @Test + public void testGetAllSecondarySkills() throws Exception { + SecondarySkill skill1 = new SecondarySkill(); + skill1.setSsid(1L); + skill1.setDescription("Java Programming"); + + SecondarySkill skill2 = new SecondarySkill(); + skill2.setSsid(2L); + skill2.setDescription("Python Programming"); + + when(secondarySkillService.getAllSecondarySkills()).thenReturn(Arrays.asList(skill1, skill2)); + + mockMvc.perform(get("/api/secondary-skill/all") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[1].ssid").value(1)) + .andExpect(jsonPath("$[1].description").value("Java Programming")) + .andExpect(jsonPath("$[2].ssid").value(2)) + .andExpect(jsonPath("$[2].description").value("Python Programming")); + } + + @Test + public void testGetSecondarySkillsByPrimarySkillId() throws Exception { + SecondarySkill skill1 = new SecondarySkill(); + skill1.setSsid(1L); + skill1.setDescription("Data Analysis"); + + SecondarySkill skill2 = new SecondarySkill(); + skill2.setSsid(2L); + skill2.setDescription("Data Visualization"); + + when(secondarySkillService.getSecondarySkillsByPrimarySkillId(100L)).thenReturn(Arrays.asList(skill1, skill2)); + + mockMvc.perform(get("/api/secondary-skill/from-primary-skill") + .param("primarySkillId", "100") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[1].ssid").value(1)) + .andExpect(jsonPath("$[1].description").value("Data Analysis")) + .andExpect(jsonPath("$[2].ssid").value(2)) + .andExpect(jsonPath("$[2].description").value("Data Visualization")); + } + + @Test + public void testCreateSecondarySkill() throws Exception { + SecondarySkill skill = new SecondarySkill(); + skill.setSsid(1L); + skill.setDescription("Machine Learning"); + + when(secondarySkillService.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(skill); + + mockMvc.perform(post("/api/secondary-skill") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"name\":\"Machine Learning\"}")) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.ssid").value(1)) + .andExpect(jsonPath("$.description").value("Machine Learning")); + } + + @Test + public void testUpdateSecondarySkill() throws Exception { + SecondarySkill updatedSkill = new SecondarySkill(); + updatedSkill.setSsid(1L); + updatedSkill.setDescription("Advanced Machine Learning"); + + when(secondarySkillService.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(updatedSkill); + + mockMvc.perform(put("/api/secondary-skill") + .contentType(MediaType.APPLICATION_JSON) + .content("{\"ssid\":1,\"description\":\"Advanced Machine Learning\"}")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.ssid").value(1)) + .andExpect(jsonPath("$.description").value("Advanced Machine Learning")); + } + + @Test + public void testDeleteSecondarySkill() throws Exception { + Long skillId = 1L; + + mockMvc.perform(delete("/api/secondary-skill") + .param("id", String.valueOf(skillId)) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isNoContent()); + } +} From 3b3361a646f2a70dcc30c4d22f1b1de0d37b83f5 Mon Sep 17 00:00:00 2001 From: mohammad Date: Mon, 11 Nov 2024 09:31:13 +0100 Subject: [PATCH 4/4] test: Adding new tests for the employeecontrollertest --- .../api/EmployeeControllerTest.java | 118 +++++++++++++++++- 1 file changed, 116 insertions(+), 2 deletions(-) diff --git a/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java b/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java index 15b3048..bb8e442 100644 --- a/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java +++ b/src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java @@ -11,10 +11,11 @@ import org.springframework.http.MediaType; import org.springframework.test.web.servlet.MockMvc; import java.time.LocalTime; +import java.util.List; import java.util.Optional; import static org.mockito.Mockito.when; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; @@ -39,7 +40,6 @@ public class EmployeeControllerTest { employee.setDEnd(LocalTime.of(17, 0)); // Assuming FormOfAddress and EmployeeSecondarySkill are also set up if needed for your test. - when(employeeService.getEmployeeById(1L)).thenReturn(Optional.of(employee)); // Act & Assert: Send GET request and expect a 200 OK status and JSON response @@ -54,4 +54,118 @@ public class EmployeeControllerTest { .andExpect(jsonPath("$.dStart").value("09:00:00")) .andExpect(jsonPath("$.dEnd").value("17:00:00")); } + + //Test if an employee is not found (404 Not Found) + @Test + public void testGetEmployeeByIdNotFound() throws Exception { + //Arrange + when(employeeService.getEmployeeById(999L)).thenReturn(Optional.empty()); + + //Act & Assert: Send GET request and expect a 404 Not Found status + mockMvc.perform(get("/api/employee") + .param("id", "999") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isNotFound()); + } + + + //Testing the getAll method for all employees + @Test + public void testGetAllEmployees() throws Exception { + //Arrange: Mock a list of employees + Employee employee1 = new Employee(); + employee1.setId(1L); + employee1.setEmployeeNr(123); + employee1.setFirstName("Mohammad"); + employee1.setLastName("Hawrami"); + + Employee employee2 = new Employee(); + employee2.setId(2L); + employee2.setEmployeeNr(124); + employee2.setFirstName("Tarik"); + employee2.setLastName("Gökmen"); + + when(employeeService.getAllEmployees()).thenReturn(List.of(employee1, employee2)); + + //Act & Assert: Send GET request and expect a 200 OK status and JSON array response + mockMvc.perform(get("/api/employees/all") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].employeeNr").value(1)) + .andExpect(jsonPath("$[1].employeeNr").value(2)); + } + + + //Testing the getFromSkill method with a specific Skilld and level + @Test + public void testGetEmployeesBySecondarySkill() throws Exception { + //Arrange: Mock a list of employees with specific skills + Employee employee = new Employee(); + employee.setId(1L); + employee.setEmployeeNr(123); + employee.setFirstName("Mohammad"); + employee.setLastName("Hawrami"); + + when(employeeService.getEmployeesBySecondarySkill(1L,2)).thenReturn(List.of(employee)); + + //Act & Assert: Send GET request and expect a 200 OK status and JSON array response + mockMvc.perform(get("/api/employee/from-skill") + .param("skillId", "1") + .param("level", "2") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$[0].id").value(1)) + .andExpect(jsonPath("$[0].employeeNr").value(123)); + } + + + //Testing the postSkillPrototype method with a valid SkillPrototype object + @Test + public void testPostSkillPrototype() throws Exception { + //Arrange: Create a SkillPrototype JSON payload + String skillPrototypeJson = "{\"skillId\":\"1\",\"level\":\"3\"}"; + + //Act & Assert: Send POST request and expect a 201 Creat status + mockMvc.perform(post("/api/employee/skill/prototype") + .content(skillPrototypeJson) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isCreated()); + } + + + //Testing the putSkillLevel method to update an existing level + @Test + public void testPutSkillLevel() throws Exception { + // Act & Assert: Send PUT request and expect a 200 OK status + mockMvc.perform(put("/api/employee/skill/level") + .param("skillId", "1") + .param("level", "5") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()); + } + + + //Testing the delete method for removing a secondary skill java + @Test + public void testDeleteSecondarySkill() throws Exception { + // Act & Assert: Send DELETE request and expect a 204 No Content status + mockMvc.perform(delete("/api/employee/skill") + .param("id", "1") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isNoContent()); + } + + + //Testing the postSkillPrototype methode with invalid payload (e.g., no Skilld) + @Test + public void testPostSkillPrototype_BadRequest() throws Exception { + // Arrange: Create an invalid JSON payload (missing skillId) + String invalidSkillPrototypeJson = "{\"level\":3}"; + + // Act & Assert: Send POST request and expect a 400 Bad Request status + mockMvc.perform(post("/api/employee/skill/prototype") + .content(invalidSkillPrototypeJson) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isBadRequest()); + } }