2021323
/
Backend
1
0
Fork 0
Code Pull Requests Activity

Merge pull request 'test: Updating the tests' (#94) from 2210970/Backend:main into restfull 

Reviewed-on: Maradona/Backend#94
pull/1/head
Mohammad Hawrami 2024-11-12 12:34:53 +01:00
parent a6d4bbcf1f 426cf0c32b
commit 90f68a504e
5 changed files with 1216 additions and 771 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

812
src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java
View File

@ -1,171 +1,641 @@
//package com.maradona.backend.controllers.api; package com.maradona.backend.controllers.api;
//
//import com.maradona.backend.controllers.api.EmployeeController; import com.maradona.backend.entities.Employee;
//import com.maradona.backend.entities.Employee; import com.maradona.backend.services.details.EmployeeDetails;
//import com.maradona.backend.services.EmployeeService; import com.maradona.backend.dto.SkillPrototype;
//import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
//import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
//import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.boot.test.mock.mockito.MockBean;
//import org.springframework.http.MediaType; import org.springframework.http.MediaType;
//import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.MockMvc;
//
//import java.time.LocalTime; import java.time.LocalTime;
//import java.util.List; import java.util.List;
//import java.util.Optional; import java.util.Optional;
//
//import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
//import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; 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.status;
//import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
//
//@WebMvcTest(EmployeeController.class) @WebMvcTest(EmployeeController.class)
//public class EmployeeControllerTest { public class EmployeeControllerTest {
//
// @Autowired @Autowired
// private MockMvc mockMvc; private MockMvc mockMvc;
//
// @MockBean @MockBean
// private EmployeeService employeeService; private EmployeeDetails employeeDetails;
//
// @Test @Test
// public void testGetEmployeeById() throws Exception { public void testGetEmployeeById() throws Exception {
// // Arrange: Mock an employee Employee employee = new Employee();
// Employee employee = new Employee(); employee.setEid(1L);
// employee.setEid(1L); employee.setEmployeeNr(123);
// employee.setEmployeeNr(123); employee.setFirstName("John");
// employee.setFirstName("John"); employee.setLastName("Doe");
// employee.setLastName("Doe"); employee.setDStart(LocalTime.of(9, 0));
// employee.setDStart(LocalTime.of(9, 0)); employee.setDEnd(LocalTime.of(17, 0));
// employee.setDEnd(LocalTime.of(17, 0));
// when(employeeDetails.getEmployeeByEid(1L)).thenReturn(Optional.of(employee));
// // Assuming FormOfAddress and EmployeeSecondarySkill are also set up if needed for your test.
// when(employeeService.getEmployeeByEid(1L)).thenReturn(Optional.of(employee)); mockMvc.perform(get("/api/employee")
// .param("id", "1")
// // Act & Assert: Send GET request and expect a 200 OK status and JSON response .contentType(MediaType.APPLICATION_JSON))
// mockMvc.perform(get("/api/employee") .andExpect(status().isOk())
// .param("id", "1") .andExpect(jsonPath("$.eid").value(1))
// .contentType(MediaType.APPLICATION_JSON)) .andExpect(jsonPath("$.employeeNr").value(123))
// .andExpect(status().isOk()) .andExpect(jsonPath("$.firstName").value("John"))
// .andExpect(jsonPath("$.id").value(1)) .andExpect(jsonPath("$.lastName").value("Doe"))
// .andExpect(jsonPath("$.employeeNr").value(123)) .andExpect(jsonPath("$.dStart").value("09:00:00"))
// .andExpect(jsonPath("$.firstName").value("John")) .andExpect(jsonPath("$.dEnd").value("17:00:00"));
// .andExpect(jsonPath("$.lastName").value("Doe")) }
// .andExpect(jsonPath("$.dStart").value("09:00:00"))
// .andExpect(jsonPath("$.dEnd").value("17:00:00")); // Test für den Fall, dass ein Employee nicht gefunden wird (404 Not Found)
// } @Test
// public void testGetEmployeeByIdNotFound() throws Exception {
// //Test if an employee is not found (404 Not Found) // Arrange: Mockt eine leere Rückgabe für eine nicht existierende Employee-ID
// @Test when(employeeDetails.getEmployeeByEid(999L)).thenReturn(Optional.empty());
// public void testGetEmployeeByIdNotFound() throws Exception {
// //Arrange // Act & Assert: Sendet eine GET-Anfrage und erwartet einen 404 Not Found-Status
// when(employeeService.getEmployeeByEid(999L)).thenReturn(Optional.empty()); mockMvc.perform(get("/api/employee")
// .param("id", "999")
// //Act & Assert: Send GET request and expect a 404 Not Found status .contentType(MediaType.APPLICATION_JSON))
// mockMvc.perform(get("/api/employee") .andExpect(status().isNotFound());
// .param("id", "999") }
// .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isNotFound()); // Test der getFromSkill-Methode mit einer spezifischen Skill-ID und einem Level
// } @Test
// public void testGetEmployeesBySecondarySkill() throws Exception {
// // Arrange: Mockt eine Liste von Mitarbeitern mit spezifischen Skills
// //Testing the getAll method for all employees Employee employee = new Employee();
// @Test employee.setEid(1L);
// public void testGetAllEmployees() throws Exception { employee.setEmployeeNr(123);
// //Arrange: Mock a list of employees employee.setFirstName("Mohammad");
// Employee employee1 = new Employee(); employee.setLastName("Hawrami");
// employee1.setEid(1L);
// employee1.setEmployeeNr(123); when(employeeDetails.getEmployeesBySecondarySkill(1L, 2)).thenReturn(List.of(employee));
// employee1.setFirstName("Mohammad");
// employee1.setLastName("Hawrami"); // Act & Assert: Sendet eine GET-Anfrage und erwartet einen 200 OK-Status sowie eine JSON-Antwort
// mockMvc.perform(get("/api/employee/from-skill")
// Employee employee2 = new Employee(); .param("ssid", "1") // Parameter "ssid" statt "skillId" verwenden
// employee2.setEid(2L); .param("level", "2")
// employee2.setEmployeeNr(124); .contentType(MediaType.APPLICATION_JSON))
// employee2.setFirstName("Tarik"); .andExpect(status().isOk())
// employee2.setLastName("Gökmen"); .andExpect(jsonPath("$[0].eid").value(1)) // "eid" statt "id"
// .andExpect(jsonPath("$[0].employeeNr").value(123)); // "employeeNr" korrekt spezifizieren
// when(employeeService.getAllEmployees()).thenReturn(List.of(employee1, employee2)); }
//
// //Act & Assert: Send GET request and expect a 200 OK status and JSON array response // Test der putSkillLevel-Methode zur Aktualisierung eines bestehenden Levels
// mockMvc.perform(get("/api/employees/all") @Test
// .contentType(MediaType.APPLICATION_JSON)) public void testPutSkillLevel() throws Exception {
// .andExpect(status().isOk()) // Act & Assert: Sendet eine PUT-Anfrage und erwartet einen 200 OK-Status
// .andExpect(jsonPath("$[0].employeeNr").value(1)) mockMvc.perform(put("/api/employee/skill/level")
// .andExpect(jsonPath("$[1].employeeNr").value(2)); .param("ssid", "1") // Korrigiert zu "ssid" statt "skillId"
// } .param("level", "5")
// .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isOk());
// //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 // Testet die delete-Methode zum Entfernen einer Secondary Skill
// Employee employee = new Employee(); @Test
// employee.setEid(1L); public void testDeleteSecondarySkill() throws Exception {
// employee.setEmployeeNr(123); // Act & Assert: Sendet eine DELETE-Anfrage und erwartet einen 204 No Content-Status
// employee.setFirstName("Mohammad"); mockMvc.perform(delete("/api/employee/skill")
// employee.setLastName("Hawrami"); .param("ssid", "1") // Korrigiert zu "ssid" statt "id"
// .contentType(MediaType.APPLICATION_JSON))
// when(employeeService.getEmployeesBySecondarySkill(1L,2)).thenReturn(List.of(employee)); .andExpect(status().isNoContent());
// }
// //Act & Assert: Send GET request and expect a 200 OK status and JSON array response
// mockMvc.perform(get("/api/employee/from-skill") // Test GET /api/employee with a valid ID but the employee has no secondary skills
// .param("skillId", "1") @Test
// .param("level", "2") public void testGetEmployeeById_NoSecondarySkills() throws Exception {
// .contentType(MediaType.APPLICATION_JSON)) Employee employee = new Employee();
// .andExpect(status().isOk()) employee.setEid(1L);
// .andExpect(jsonPath("$[0].id").value(1)) employee.setEmployeeNr(123);
// .andExpect(jsonPath("$[0].employeeNr").value(123)); employee.setFirstName("John");
// } employee.setLastName("Doe");
//
// when(employeeDetails.getEmployeeByEid(1L)).thenReturn(Optional.of(employee));
// //Testing the postSkillPrototype method with a valid SkillPrototype object
// @Test mockMvc.perform(get("/api/employee")
// public void testPostSkillPrototype() throws Exception { .param("id", "1")
// //Arrange: Create a SkillPrototype JSON payload .contentType(MediaType.APPLICATION_JSON))
// String skillPrototypeJson = "{\"skillId\":\"1\",\"level\":\"3\"}"; .andExpect(status().isOk())
// .andExpect(jsonPath("$.eid").value(1))
// //Act & Assert: Send POST request and expect a 201 Creat status .andExpect(jsonPath("$.employeeNr").value(123))
// mockMvc.perform(post("/api/employee/skill/prototype") .andExpect(jsonPath("$.firstName").value("John"))
// .content(skillPrototypeJson) .andExpect(jsonPath("$.lastName").value("Doe"))
// .contentType(MediaType.APPLICATION_JSON)) .andExpect(jsonPath("$.secondarySkills").doesNotExist());
// .andExpect(status().isCreated()); }
// }
// // Test GET /api/employee/all with employees having varied skill levels
// @Test
// //Testing the putSkillLevel method to update an existing level public void testGetAllEmployees_WithVariedSkills() throws Exception {
// @Test Employee employee1 = new Employee();
// public void testPutSkillLevel() throws Exception { employee1.setEid(1L);
// // Act & Assert: Send PUT request and expect a 200 OK status employee1.setEmployeeNr(123);
// mockMvc.perform(put("/api/employee/skill/level") employee1.setFirstName("Alice");
// .param("skillId", "1") employee1.setLastName("Smith");
// .param("level", "5")
// .contentType(MediaType.APPLICATION_JSON)) Employee employee2 = new Employee();
// .andExpect(status().isOk()); employee2.setEid(2L);
// } employee2.setEmployeeNr(124);
// employee2.setFirstName("Bob");
// employee2.setLastName("Johnson");
// //Testing the delete method for removing a secondary skill java
// @Test when(employeeDetails.getAllEmployees()).thenReturn(List.of(employee1, employee2));
// public void testDeleteSecondarySkill() throws Exception {
// // Act & Assert: Send DELETE request and expect a 204 No Content status mockMvc.perform(get("/api/employee/all")
// mockMvc.perform(delete("/api/employee/skill") .contentType(MediaType.APPLICATION_JSON))
// .param("id", "1") .andExpect(status().isOk())
// .contentType(MediaType.APPLICATION_JSON)) .andExpect(jsonPath("$[0].eid").value(1))
// .andExpect(status().isNoContent()); .andExpect(jsonPath("$[0].firstName").value("Alice"))
// } .andExpect(jsonPath("$[1].eid").value(2))
// .andExpect(jsonPath("$[1].firstName").value("Bob"));
// }
// //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) // Test PUT /api/employee/skill/level to ensure updating to the minimum level
// String invalidSkillPrototypeJson = "{\"level\":3}"; @Test
// public void testPutSkillLevel_MinLevel() throws Exception {
// // Act & Assert: Send POST request and expect a 400 Bad Request status mockMvc.perform(put("/api/employee/skill/level")
// mockMvc.perform(post("/api/employee/skill/prototype") .param("skillId", "1")
// .content(invalidSkillPrototypeJson) .param("level", "1")
// .contentType(MediaType.APPLICATION_JSON)) .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isBadRequest()); .andExpect(status().isOk());
// } }
//}
// Test DELETE /api/employee/skill by calling delete on an existing skill
@Test
public void testDeleteExistingSecondarySkill() throws Exception {
mockMvc.perform(delete("/api/employee/skill")
.param("id", "1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNoContent());
}
// Test GET /api/employee/from-skill with employees at boundary skill levels
@Test
public void testGetEmployeesBySecondarySkill_BoundaryLevels() throws Exception {
Employee employee = new Employee();
employee.setEid(1L);
employee.setEmployeeNr(123);
employee.setFirstName("John");
employee.setLastName("Doe");
when(employeeDetails.getEmployeesBySecondarySkill(1L, 1)).thenReturn(List.of(employee));
when(employeeDetails.getEmployeesBySecondarySkill(1L, 5)).thenReturn(List.of(employee));
// Test with minimum level
mockMvc.perform(get("/api/employee/from-skill")
.param("skillId", "1")
.param("level", "1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$[0].eid").value(1))
.andExpect(jsonPath("$[0].employeeNr").value(123));
// Test with maximum level
mockMvc.perform(get("/api/employee/from-skill")
.param("skillId", "1")
.param("level", "5")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$[0].eid").value(1))
.andExpect(jsonPath("$[0].employeeNr").value(123));
}
// Test GET /api/employee with an ID at the upper limit of Long values
@Test
public void testGetEmployeeById_MaxLongValue() throws Exception {
Employee employee = new Employee();
employee.setEid(Long.MAX_VALUE);
employee.setEmployeeNr(99999);
employee.setFirstName("Max");
employee.setLastName("Value");
when(employeeDetails.getEmployeeByEid(Long.MAX_VALUE)).thenReturn(Optional.of(employee));
mockMvc.perform(get("/api/employee")
.param("id", String.valueOf(Long.MAX_VALUE))
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.eid").value(Long.MAX_VALUE))
.andExpect(jsonPath("$.firstName").value("Max"))
.andExpect(jsonPath("$.lastName").value("Value"));
}
// Test GET /api/employee mit einer nicht existierenden ID (extrem großer Wert)
@Test
public void testGetEmployeeById_NonExistentHighId() throws Exception {
when(employeeDetails.getEmployeeByEid(Long.MAX_VALUE)).thenReturn(Optional.empty());
mockMvc.perform(get("/api/employee")
.param("id", String.valueOf(Long.MAX_VALUE))
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNotFound());
}
// Test GET /api/employee/from-skill ohne level Parameter
@Test
public void testGetEmployeesBySecondarySkill_MissingLevelParameter() throws Exception {
mockMvc.perform(get("/api/employee/from-skill")
.param("skillId", "1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isBadRequest());
}
// Test PUT /api/employee/skill/level mit nicht numerischem Skill ID-Wert
@Test
public void testPutSkillLevel_InvalidSkillIdFormat() throws Exception {
mockMvc.perform(put("/api/employee/skill/level")
.param("skillId", "abc") // ungültiger Skill ID-Wert
.param("level", "3")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isBadRequest());
}
// Test DELETE /api/employee/skill ohne id Parameter
@Test
public void testDeleteSecondarySkill_MissingIdParameter() throws Exception {
mockMvc.perform(delete("/api/employee/skill")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isBadRequest());
}
// Test PUT /api/employee/skill/level mit maximal gültigem Level
@Test
public void testPutSkillLevel_MaxLevel() throws Exception {
mockMvc.perform(put("/api/employee/skill/level")
.param("skillId", "1")
.param("level", "5") // angenommen, 5 ist das maximale Level
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
}
// Test GET /api/employee/all mit leeren Rückgabedaten
@Test
public void testGetAllEmployees_EmptyList() throws Exception {
when(employeeDetails.getAllEmployees()).thenReturn(List.of());
mockMvc.perform(get("/api/employee/all")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$").isEmpty());
}
// Test GET /api/employee mit einem Mitarbeiter mit vollständigen Details und spezifischen Arbeitszeiten
@Test
public void testGetEmployeeById_WithFullDetails() throws Exception {
Employee employee = new Employee();
employee.setEid(10L);
employee.setEmployeeNr(1010);
employee.setFirstName("Alice");
employee.setLastName("Wonderland");
employee.setDStart(LocalTime.of(8, 30));
employee.setDEnd(LocalTime.of(16, 30));
when(employeeDetails.getEmployeeByEid(10L)).thenReturn(Optional.of(employee));
mockMvc.perform(get("/api/employee")
.param("id", "10")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.eid").value(10))
.andExpect(jsonPath("$.employeeNr").value(1010))
.andExpect(jsonPath("$.firstName").value("Alice"))
.andExpect(jsonPath("$.lastName").value("Wonderland"))
.andExpect(jsonPath("$.dStart").value("08:30:00"))
.andExpect(jsonPath("$.dEnd").value("16:30:00"));
}
// Test GET /api/employee/all mit mehreren Einträgen
@Test
public void testGetAllEmployees_WithMultipleEntries() throws Exception {
Employee employee1 = new Employee();
employee1.setEid(1L);
employee1.setEmployeeNr(100);
employee1.setFirstName("John");
employee1.setLastName("Doe");
Employee employee2 = new Employee();
employee2.setEid(2L);
employee2.setEmployeeNr(101);
employee2.setFirstName("Jane");
employee2.setLastName("Doe");
Employee employee3 = new Employee();
employee3.setEid(3L);
employee3.setEmployeeNr(102);
employee3.setFirstName("Jake");
employee3.setLastName("Smith");
when(employeeDetails.getAllEmployees()).thenReturn(List.of(employee1, employee2, employee3));
mockMvc.perform(get("/api/employee/all")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(3))
.andExpect(jsonPath("$[0].eid").value(1))
.andExpect(jsonPath("$[1].eid").value(2))
.andExpect(jsonPath("$[2].eid").value(3))
.andExpect(jsonPath("$[0].firstName").value("John"))
.andExpect(jsonPath("$[1].firstName").value("Jane"))
.andExpect(jsonPath("$[2].firstName").value("Jake"));
}
// Test POST /api/employee/skill/prototype für einen Prototyp mit hohem Levelwert
@Test
public void testPostSkillPrototype_HighLevel() throws Exception {
String skillPrototypeJson = "{\"skillId\":\"2\",\"level\":\"4\"}";
mockMvc.perform(post("/api/employee/skill/prototype")
.content(skillPrototypeJson)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isCreated());
}
// Test GET /api/employee/from-skill mit einem spezifischen Skill-Level und mehreren Mitarbeitern
@Test
public void testGetEmployeesBySecondarySkill_WithMultipleMatchingEmployees() throws Exception {
Employee employee1 = new Employee();
employee1.setEid(4L);
employee1.setEmployeeNr(200);
employee1.setFirstName("Emma");
employee1.setLastName("Brown");
Employee employee2 = new Employee();
employee2.setEid(5L);
employee2.setEmployeeNr(201);
employee2.setFirstName("Liam");
employee2.setLastName("Wilson");
when(employeeDetails.getEmployeesBySecondarySkill(2L, 3)).thenReturn(List.of(employee1, employee2));
mockMvc.perform(get("/api/employee/from-skill")
.param("skillId", "2")
.param("level", "3")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(2))
.andExpect(jsonPath("$[0].eid").value(4))
.andExpect(jsonPath("$[1].eid").value(5))
.andExpect(jsonPath("$[0].firstName").value("Emma"))
.andExpect(jsonPath("$[1].firstName").value("Liam"));
}
// Test PUT /api/employee/skill/level mit minimalem Levelwert
@Test
public void testPutSkillLevel_MinimumLevel() throws Exception {
mockMvc.perform(put("/api/employee/skill/level")
.param("skillId", "3")
.param("level", "1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
}
// Test DELETE /api/employee/skill für einen vorhandenen Skill
@Test
public void testDeleteSecondarySkill_WithValidSkillId() throws Exception {
mockMvc.perform(delete("/api/employee/skill")
.param("id", "2")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNoContent());
}
// Test GET /api/employee für einen Mitarbeiter mit spezifischen Details
@Test
public void testGetEmployeeById_WithSpecificDetails() throws Exception {
Employee employee = new Employee();
employee.setEid(15L);
employee.setEmployeeNr(555);
employee.setFirstName("Evelyn");
employee.setLastName("Hall");
employee.setDStart(LocalTime.of(7, 45));
employee.setDEnd(LocalTime.of(15, 45));
when(employeeDetails.getEmployeeByEid(15L)).thenReturn(Optional.of(employee));
mockMvc.perform(get("/api/employee")
.param("id", "15")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.eid").value(15))
.andExpect(jsonPath("$.employeeNr").value(555))
.andExpect(jsonPath("$.firstName").value("Evelyn"))
.andExpect(jsonPath("$.lastName").value("Hall"))
.andExpect(jsonPath("$.dStart").value("07:45:00"))
.andExpect(jsonPath("$.dEnd").value("15:45:00"));
}
// Test GET /api/employee/all mit einer einzelnen Eintragung
@Test
public void testGetAllEmployees_WithSingleEntry() throws Exception {
Employee employee = new Employee();
employee.setEid(20L);
employee.setEmployeeNr(202);
employee.setFirstName("Michael");
employee.setLastName("Jordan");
when(employeeDetails.getAllEmployees()).thenReturn(List.of(employee));
mockMvc.perform(get("/api/employee/all")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(1))
.andExpect(jsonPath("$[0].eid").value(20))
.andExpect(jsonPath("$[0].employeeNr").value(202))
.andExpect(jsonPath("$[0].firstName").value("Michael"))
.andExpect(jsonPath("$[0].lastName").value("Jordan"));
}
// Test GET /api/employee/from-skill für ein Skill-Level mit nur einem passenden Mitarbeiter
@Test
public void testGetEmployeesBySecondarySkill_SingleEmployee() throws Exception {
Employee employee = new Employee();
employee.setEid(30L);
employee.setEmployeeNr(303);
employee.setFirstName("Sophia");
employee.setLastName("Brown");
when(employeeDetails.getEmployeesBySecondarySkill(3L, 2)).thenReturn(List.of(employee));
mockMvc.perform(get("/api/employee/from-skill")
.param("skillId", "3")
.param("level", "2")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(1))
.andExpect(jsonPath("$[0].eid").value(30))
.andExpect(jsonPath("$[0].employeeNr").value(303))
.andExpect(jsonPath("$[0].firstName").value("Sophia"))
.andExpect(jsonPath("$[0].lastName").value("Brown"));
}
// Test PUT /api/employee/skill/level für eine existierende Fähigkeit und mittleres Level
@Test
public void testPutSkillLevel_MidLevel() throws Exception {
mockMvc.perform(put("/api/employee/skill/level")
.param("skillId", "7")
.param("level", "3")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
}
// Test DELETE /api/employee/skill für einen existierenden Skill, um sicherzustellen, dass der Skill gelöscht wird
@Test
public void testDeleteSecondarySkill_ValidSkill() throws Exception {
mockMvc.perform(delete("/api/employee/skill")
.param("id", "3")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNoContent());
}
// Test GET /api/employee/all mit mehreren Einträgen, die verschiedene Abteilungen repräsentieren könnten
@Test
public void testGetAllEmployees_WithDepartmentVariety() throws Exception {
Employee employee1 = new Employee();
employee1.setEid(100L);
employee1.setEmployeeNr(300);
employee1.setFirstName("Lara");
employee1.setLastName("Croft");
Employee employee2 = new Employee();
employee2.setEid(101L);
employee2.setEmployeeNr(301);
employee2.setFirstName("Nathan");
employee2.setLastName("Drake");
Employee employee3 = new Employee();
employee3.setEid(102L);
employee3.setEmployeeNr(302);
employee3.setFirstName("Samus");
employee3.setLastName("Aran");
when(employeeDetails.getAllEmployees()).thenReturn(List.of(employee1, employee2, employee3));
mockMvc.perform(get("/api/employee/all")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(3))
.andExpect(jsonPath("$[0].eid").value(100))
.andExpect(jsonPath("$[1].eid").value(101))
.andExpect(jsonPath("$[2].eid").value(102))
.andExpect(jsonPath("$[0].firstName").value("Lara"))
.andExpect(jsonPath("$[1].firstName").value("Nathan"))
.andExpect(jsonPath("$[2].firstName").value("Samus"));
}
// Test GET /api/employee für einen Mitarbeiter mit speziellen Arbeitszeiten (z.B. Nachtarbeit)
@Test
public void testGetEmployeeById_NightShift() throws Exception {
Employee employee = new Employee();
employee.setEid(50L);
employee.setEmployeeNr(505);
employee.setFirstName("Tom");
employee.setLastName("Night");
employee.setDStart(LocalTime.of(22, 0)); // Beginnt um 22:00 Uhr
employee.setDEnd(LocalTime.of(6, 0)); // Endet um 6:00 Uhr
when(employeeDetails.getEmployeeByEid(50L)).thenReturn(Optional.of(employee));
mockMvc.perform(get("/api/employee")
.param("id", "50")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.eid").value(50))
.andExpect(jsonPath("$.employeeNr").value(505))
.andExpect(jsonPath("$.firstName").value("Tom"))
.andExpect(jsonPath("$.lastName").value("Night"))
.andExpect(jsonPath("$.dStart").value("22:00:00"))
.andExpect(jsonPath("$.dEnd").value("06:00:00"));
}
// Test GET /api/employee/all mit einer Kombination aus Vollzeit und Teilzeitmitarbeitern
@Test
public void testGetAllEmployees_FullAndPartTime() throws Exception {
Employee fullTimeEmployee = new Employee();
fullTimeEmployee.setEid(60L);
fullTimeEmployee.setEmployeeNr(606);
fullTimeEmployee.setFirstName("Alice");
fullTimeEmployee.setLastName("Fulltime");
fullTimeEmployee.setDStart(LocalTime.of(9, 0));
fullTimeEmployee.setDEnd(LocalTime.of(17, 0));
Employee partTimeEmployee = new Employee();
partTimeEmployee.setEid(61L);
partTimeEmployee.setEmployeeNr(607);
partTimeEmployee.setFirstName("Bob");
partTimeEmployee.setLastName("Parttime");
partTimeEmployee.setDStart(LocalTime.of(10, 0));
partTimeEmployee.setDEnd(LocalTime.of(14, 0));
when(employeeDetails.getAllEmployees()).thenReturn(List.of(fullTimeEmployee, partTimeEmployee));
mockMvc.perform(get("/api/employee/all")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(2))
.andExpect(jsonPath("$[0].eid").value(60))
.andExpect(jsonPath("$[1].eid").value(61))
.andExpect(jsonPath("$[0].firstName").value("Alice"))
.andExpect(jsonPath("$[1].firstName").value("Bob"));
}
// Test PUT /api/employee/skill/level für ein Update auf das maximal erlaubte Level
@Test
public void testPutSkillLevel_MaxAllowedLevel() throws Exception {
mockMvc.perform(put("/api/employee/skill/level")
.param("skillId", "10")
.param("level", "5") // Maximal erlaubtes Level
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
}
// Test GET /api/employee/from-skill mit mehreren Mitarbeitern und hohem Level
@Test
public void testGetEmployeesBySecondarySkill_HighLevelMultipleEmployees() throws Exception {
Employee employee1 = new Employee();
employee1.setEid(70L);
employee1.setEmployeeNr(700);
employee1.setFirstName("John");
employee1.setLastName("Highskill");
Employee employee2 = new Employee();
employee2.setEid(71L);
employee2.setEmployeeNr(701);
employee2.setFirstName("Jane");
employee2.setLastName("Expert");
when(employeeDetails.getEmployeesBySecondarySkill(5L, 5)).thenReturn(List.of(employee1, employee2));
mockMvc.perform(get("/api/employee/from-skill")
.param("skillId", "5")
.param("level", "5")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$.length()").value(2))
.andExpect(jsonPath("$[0].eid").value(70))
.andExpect(jsonPath("$[1].eid").value(71))
.andExpect(jsonPath("$[0].firstName").value("John"))
.andExpect(jsonPath("$[1].firstName").value("Jane"));
}
// Test DELETE /api/employee/skill für einen vorhandenen Skill mit Bestätigung der Löschung
@Test
public void testDeleteSecondarySkill_WithConfirmation() throws Exception {
mockMvc.perform(delete("/api/employee/skill")
.param("id", "5")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNoContent());
}
}

265
src/test/java/com/maradona/backend/controllers/api/FormOfAdressControllerTest.java
View File

@ -1,131 +1,134 @@
//package com.maradona.backend.controllers.api; package com.maradona.backend.controllers.api;
//
//import com.maradona.backend.entities.FormOfAddress; import com.maradona.backend.entities.FormOfAddress;
//import com.maradona.backend.services.FormOfAddressService; import com.maradona.backend.services.details.FormOfAddressDetails;
//import org.junit.jupiter.api.Test; import com.maradona.backend.services.actions.FormOfAddressActions;
//import org.springframework.beans.factory.annotation.Autowired; import org.junit.jupiter.api.Test;
//import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
//import org.springframework.http.MediaType; import org.springframework.boot.test.mock.mockito.MockBean;
//import org.springframework.test.web.servlet.MockMvc; import org.springframework.http.MediaType;
// import org.springframework.test.web.servlet.MockMvc;
//import java.util.Optional;
//import java.util.Arrays; import java.util.Optional;
// import java.util.Arrays;
//import static org.mockito.ArgumentMatchers.any;
//import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.any;
//import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
//import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; 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.status;
//import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
//
//@WebMvcTest(FormOfAdressController.class) @WebMvcTest(FormOfAdressController.class)
//public class FormOfAdressControllerTest { public class FormOfAdressControllerTest {
//
// @Autowired @Autowired
// private MockMvc mockMvc; private MockMvc mockMvc;
//
// @MockBean @MockBean
// private FormOfAddressService formOfAdressService; private FormOfAddressDetails formOfAdressService;
//
// @Test @MockBean
// public void testGetFormOfAdressById() throws Exception { private FormOfAddressActions formOfAdressActions;
// FormOfAddress formOfAddress = new FormOfAddress();
// formOfAddress.setFid(1L); @Test
// formOfAddress.setDescription("Mr."); public void testGetFormOfAdressById() throws Exception {
// FormOfAddress formOfAddress = new FormOfAddress();
// when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.of(formOfAddress)); formOfAddress.setFid(1L);
// formOfAddress.setDescription("Mr.");
// mockMvc.perform(get("/api/form-of-adress")
// .param("id", "1") when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.of(formOfAddress));
// .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isOk()) mockMvc.perform(get("/api/form-of-adress")
// .andExpect(jsonPath("$.id").value(1)) .param("fid", "1")
// .andExpect(jsonPath("$.description").value("Mr.")); .contentType(MediaType.APPLICATION_JSON))
// } .andExpect(status().isOk())
// .andExpect(jsonPath("$.fid").value(1))
// @Test .andExpect(jsonPath("$.description").value("Mr."));
// public void testGetAllFormOfAdresses() throws Exception { }
// FormOfAddress form1 = new FormOfAddress();
// form1.setFid(1L); @Test
// form1.setDescription("Mr."); public void testGetAllFormOfAdresses() throws Exception {
// FormOfAddress form1 = new FormOfAddress();
// FormOfAddress form2 = new FormOfAddress(); form1.setFid(1L);
// form2.setFid(2L); form1.setDescription("Mr.");
// form2.setDescription("Ms.");
// FormOfAddress form2 = new FormOfAddress();
// when(formOfAdressService.getAllFormOfAddresses()).thenReturn(Arrays.asList(form1, form2)); form2.setFid(2L);
// form2.setDescription("Ms.");
// mockMvc.perform(get("/api/form-of-adress/all")
// .contentType(MediaType.APPLICATION_JSON)) when(formOfAdressService.getAllFormOfAddresses()).thenReturn(Arrays.asList(form1, form2));
// .andExpect(status().isOk())
// .andExpect(jsonPath("$[0].id").value(1)) mockMvc.perform(get("/api/form-of-adress/all")
// .andExpect(jsonPath("$[0].description").value("Mr.")) .contentType(MediaType.APPLICATION_JSON))
// .andExpect(jsonPath("$[1].id").value(2)) .andExpect(status().isOk())
// .andExpect(jsonPath("$[1].description").value("Ms.")); .andExpect(jsonPath("$[0].fid").value(1))
// } .andExpect(jsonPath("$[0].description").value("Mr."))
// .andExpect(jsonPath("$[1].fid").value(2))
// @Test .andExpect(jsonPath("$[1].description").value("Ms."));
// public void testCreateFormOfAdress() throws Exception { }
// FormOfAddress formOfAddress = new FormOfAddress();
// formOfAddress.setFid(1L); @Test
// formOfAddress.setDescription("Dr."); public void testCreateFormOfAdress() throws Exception {
// FormOfAddress formOfAddress = new FormOfAddress();
// when(formOfAdressService.saveFormOfAddress(any(FormOfAddress.class))).thenReturn(formOfAddress); formOfAddress.setFid(1L);
// formOfAddress.setDescription("Dr.");
// mockMvc.perform(post("/api/form-of-adress")
// .contentType(MediaType.APPLICATION_JSON) when(formOfAdressActions.saveFormOfAddress(any(FormOfAddress.class))).thenReturn(formOfAddress);
// .content("\"Dr.\""))
// .andExpect(status().isOk()); mockMvc.perform(post("/api/form-of-adress")
// } .contentType(MediaType.APPLICATION_JSON)
// .content("\"Dr.\""))
// @Test .andExpect(status().isOk());
// public void testUpdateFormOfAdress() throws Exception { }
// FormOfAddress existingForm = new FormOfAddress();
// existingForm.setFid(1L); @Test
// existingForm.setDescription("Mr."); public void testUpdateFormOfAdress() throws Exception {
// FormOfAddress existingForm = new FormOfAddress();
// when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.of(existingForm)); existingForm.setFid(1L);
// existingForm.setDescription("Mr.");
// mockMvc.perform(put("/api/form-of-adress")
// .param("id", "1") when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.of(existingForm));
// .contentType(MediaType.APPLICATION_JSON)
// .content("\"Prof.\"")) mockMvc.perform(put("/api/form-of-adress")
// .andExpect(status().isOk()); .param("fid", "1")
// } .contentType(MediaType.APPLICATION_JSON)
// .content("\"Prof.\""))
// @Test .andExpect(status().isOk());
// public void testUpdateFormOfAdressNotFound() throws Exception { }
// when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.empty());
// @Test
// mockMvc.perform(put("/api/form-of-adress") public void testUpdateFormOfAdressNotFound() throws Exception {
// .param("id", "1") when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.empty());
// .contentType(MediaType.APPLICATION_JSON)
// .content("\"Prof.\"")) mockMvc.perform(put("/api/form-of-adress")
// .andExpect(status().isNotFound()); .param("fid", "1")
// } .contentType(MediaType.APPLICATION_JSON)
// .content("\"Prof.\""))
// @Test .andExpect(status().isNotFound());
// public void testDeleteFormOfAdress() throws Exception { }
// FormOfAddress formOfAddress = new FormOfAddress();
// formOfAddress.setFid(1L); @Test
// formOfAddress.setDescription("Mr."); public void testDeleteFormOfAdress() throws Exception {
// FormOfAddress formOfAddress = new FormOfAddress();
// when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.of(formOfAddress)); formOfAddress.setFid(1L);
// formOfAddress.setDescription("Mr.");
// mockMvc.perform(delete("/api/form-of-adress")
// .param("id", "1") when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.of(formOfAddress));
// .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isOk()); mockMvc.perform(delete("/api/form-of-adress")
// } .param("fid", "1")
// .contentType(MediaType.APPLICATION_JSON))
// @Test .andExpect(status().isOk());
// public void testDeleteFormOfAdressNotFound() throws Exception { }
// when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.empty());
// @Test
// mockMvc.perform(delete("/api/form-of-adress") public void testDeleteFormOfAdressNotFound() throws Exception {
// .param("id", "1") when(formOfAdressService.getFormOfAddressByFid(1L)).thenReturn(Optional.empty());
// .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isNotFound()); mockMvc.perform(delete("/api/form-of-adress")
// } .param("fid", "1")
//} .contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNotFound());
}
}

286
src/test/java/com/maradona/backend/controllers/api/PrimarySkillControllerTest.java
View File

@ -1,140 +1,146 @@
//package com.maradona.backend.controllers.api; package com.maradona.backend.controllers.api;
//
//import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
//import com.maradona.backend.entities.PrimarySkill; import com.maradona.backend.entities.PrimarySkill;
//import com.maradona.backend.services.PrimarySkillService; import com.maradona.backend.services.actions.PrimarySkillActions;
//import com.maradona.backend.services.SecondarySkillService; import com.maradona.backend.services.details.PrimarySkillDetails;
//import org.junit.jupiter.api.BeforeEach; import com.maradona.backend.services.details.SecondarySkillDetails;
//import org.junit.jupiter.api.Test; import org.junit.jupiter.api.BeforeEach;
//import org.mockito.*; import org.junit.jupiter.api.Test;
//import org.springframework.http.MediaType; import org.mockito.InjectMocks;
//import org.springframework.test.web.servlet.MockMvc; import org.mockito.Mock;
//import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; import org.mockito.Mockito;
//import org.springframework.test.web.servlet.result.MockMvcResultMatchers; import org.mockito.MockitoAnnotations;
//import org.springframework.test.web.servlet.setup.MockMvcBuilders; import org.springframework.http.MediaType;
// import org.springframework.test.web.servlet.MockMvc;
//import java.util.List; import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
//import java.util.Optional; import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
// import org.springframework.test.web.servlet.setup.MockMvcBuilders;
//import static org.mockito.ArgumentMatchers.any;
// import java.util.List;
//public class PrimarySkillControllerTest { import java.util.Optional;
//
// private MockMvc mockMvc; import static org.mockito.ArgumentMatchers.any;
//
// @Mock public class PrimarySkillControllerTest {
// private PrimarySkillService primarySkillService;
// private MockMvc mockMvc;
// @Mock
// private SecondarySkillService secondarySkillService; @Mock
// private PrimarySkillDetails primarySkillDetails;
// @InjectMocks
// private PrimarySkillController primarySkillController; @Mock
// private PrimarySkillActions primarySkillActions;
// private PrimarySkill primarySkill;
// @Mock
// @BeforeEach private SecondarySkillDetails secondarySkillDetails;
// public void setUp() {
// MockitoAnnotations.openMocks(this); @InjectMocks
// mockMvc = MockMvcBuilders.standaloneSetup(primarySkillController).build(); private PrimarySkillController primarySkillController;
//
// // Initialisieren eines Beispiels für PrimarySkill private PrimarySkill primarySkill;
// primarySkill = new PrimarySkill();
// primarySkill.setPsid(1L); @BeforeEach
// primarySkill.setDescription("Test Primary Skill"); public void setUp() {
// } MockitoAnnotations.openMocks(this);
// mockMvc = MockMvcBuilders.standaloneSetup(primarySkillController).build();
// @Test
// public void testGetPrimarySkillById_Success() throws Exception { // Initialisieren eines Beispiels für PrimarySkill
// // Mock das Service, um ein PrimarySkill zu liefern primarySkill = new PrimarySkill();
// Mockito.when(primarySkillService.getPrimarySkillByPsid(1L)).thenReturn(Optional.of(primarySkill)); primarySkill.setPsid(1L);
// primarySkill.setDescription("Test Primary Skill");
// // Führe die GET-Anfrage aus }
// mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill")
// .param("id", "1")) @Test
// .andExpect(MockMvcResultMatchers.status().isOk()) public void testGetPrimarySkillById_Success() throws Exception {
// .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1)) // Mock das Service, um ein PrimarySkill zu liefern
// .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); Mockito.when(primarySkillDetails.getPrimarySkillByPsid(1L)).thenReturn(Optional.of(primarySkill));
//
// // Verifiziere, dass der Service aufgerufen wurde // Führe die GET-Anfrage aus
// Mockito.verify(primarySkillService, Mockito.times(1)).getPrimarySkillByPsid(1L); mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill")
// } .param("pid", "1"))
// .andExpect(MockMvcResultMatchers.status().isOk())
// @Test .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1))
// public void testGetAllPrimarySkills() throws Exception { .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill"));
// // Mock das Service, um eine Liste von PrimarySkills zu liefern
// Mockito.when(primarySkillService.getAllPrimarySkills()).thenReturn(List.of(primarySkill)); // Verifiziere, dass der Service aufgerufen wurde
// Mockito.verify(primarySkillDetails, Mockito.times(1)).getPrimarySkillByPsid(1L);
// // Führe die GET-Anfrage aus }
// mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill/all"))
// .andExpect(MockMvcResultMatchers.status().isOk()) @Test
// .andExpect(MockMvcResultMatchers.jsonPath("$[0].psid").value(1)) public void testGetAllPrimarySkills() throws Exception {
// .andExpect(MockMvcResultMatchers.jsonPath("$[0].description").value("Test Primary Skill")); // Mock das Service, um eine Liste von PrimarySkills zu liefern
// Mockito.when(primarySkillDetails.getAllPrimarySkills()).thenReturn(List.of(primarySkill));
// // Verifiziere, dass der Service aufgerufen wurde
// Mockito.verify(primarySkillService, Mockito.times(1)).getAllPrimarySkills(); // Führe die GET-Anfrage aus
// } mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill/all"))
// .andExpect(MockMvcResultMatchers.status().isOk())
// @Test .andExpect(MockMvcResultMatchers.jsonPath("$[0].psid").value(1))
// public void testCreatePrimarySkill() throws Exception { .andExpect(MockMvcResultMatchers.jsonPath("$[0].description").value("Test Primary Skill"));
// // Mock das Service, um das PrimarySkill zu speichern
// Mockito.when(primarySkillService.savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class))).thenReturn(primarySkill); // Verifiziere, dass der Service aufgerufen wurde
// Mockito.verify(primarySkillDetails, Mockito.times(1)).getAllPrimarySkills();
// // Führe die POST-Anfrage aus }
// mockMvc.perform(MockMvcRequestBuilders.post("/api/primary-skill")
// .contentType(MediaType.APPLICATION_JSON) @Test
// .content(new ObjectMapper().writeValueAsString(primarySkill))) // Hier wird das PrimarySkill als JSON übermittelt public void testCreatePrimarySkill() throws Exception {
// .andExpect(MockMvcResultMatchers.status().isCreated()) // Erwartet den Statuscode 201 Created // Mock das Service, um das PrimarySkill zu speichern
// .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1)) // Überprüft das psid in der Antwort Mockito.when(primarySkillActions.savePrimarySkill(any(PrimarySkill.class))).thenReturn(primarySkill);
// .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); // Überprüft die Beschreibung
// // Führe die POST-Anfrage aus
// // Verifiziere, dass der Service aufgerufen wurde mockMvc.perform(MockMvcRequestBuilders.post("/api/primary-skill")
// Mockito.verify(primarySkillService, Mockito.times(1)).savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class)); .contentType(MediaType.APPLICATION_JSON)
// } .content(new ObjectMapper().writeValueAsString(primarySkill))) // Hier wird das PrimarySkill als JSON übermittelt
// .andExpect(MockMvcResultMatchers.status().isCreated())
// .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1))
// @Test .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill"));
// public void testUpdatePrimarySkill() throws Exception {
// // Mock das Service, um das PrimarySkill zu speichern // Verifiziere, dass der Service aufgerufen wurde
// Mockito.when(primarySkillService.savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class))).thenReturn(primarySkill); Mockito.verify(primarySkillActions, Mockito.times(1)).savePrimarySkill(any(PrimarySkill.class));
// }
// // Führe die PUT-Anfrage aus
// mockMvc.perform(MockMvcRequestBuilders.put("/api/primary-skill") @Test
// .contentType(MediaType.APPLICATION_JSON) public void testUpdatePrimarySkill() throws Exception {
// .content(new ObjectMapper().writeValueAsString(primarySkill))) // Mock das Service, um das PrimarySkill zu speichern
// .andExpect(MockMvcResultMatchers.status().isOk()) Mockito.when(primarySkillActions.savePrimarySkill(any(PrimarySkill.class))).thenReturn(primarySkill);
// .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1))
// .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); // Führe die PUT-Anfrage aus
// mockMvc.perform(MockMvcRequestBuilders.put("/api/primary-skill")
// // Verifiziere, dass der Service aufgerufen wurde .contentType(MediaType.APPLICATION_JSON)
// Mockito.verify(primarySkillService, Mockito.times(1)).savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class)); .content(new ObjectMapper().writeValueAsString(primarySkill)))
// } .andExpect(MockMvcResultMatchers.status().isOk())
// .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1))
// @Test .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill"));
// public void testDeletePrimarySkill_Success() throws Exception {
// // Mock das Service, um das PrimarySkill zu liefern // Verifiziere, dass der Service aufgerufen wurde
// Mockito.when(primarySkillService.getPrimarySkillByPsid(1L)).thenReturn(Optional.of(primarySkill)); Mockito.verify(primarySkillActions, Mockito.times(1)).savePrimarySkill(any(PrimarySkill.class));
// }
// // Führe die DELETE-Anfrage aus
// mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill") @Test
// .param("id", "1")) public void testDeletePrimarySkill_Success() throws Exception {
// .andExpect(MockMvcResultMatchers.status().isNoContent()); // Mock das Service, um das PrimarySkill zu liefern
// Mockito.when(primarySkillDetails.getPrimarySkillByPsid(1L)).thenReturn(Optional.of(primarySkill));
// // Verifiziere, dass der Service aufgerufen wurde
// Mockito.verify(primarySkillService, Mockito.times(1)).deletePrimarySkill(1L); // Führe die DELETE-Anfrage aus
// } mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill")
// .param("pid", "1"))
// @Test .andExpect(MockMvcResultMatchers.status().isNoContent());
// public void testDeletePrimarySkill_NotFound() throws Exception {
// // Mock das Service, um das PrimarySkill nicht zu finden // Verifiziere, dass der Service aufgerufen wurde
// Mockito.when(primarySkillService.getPrimarySkillByPsid(1L)).thenReturn(Optional.empty()); Mockito.verify(primarySkillActions, Mockito.times(1)).deletePrimarySkill(1L);
// }
// // Führe die DELETE-Anfrage aus
// mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill") @Test
// .param("id", "1")) public void testDeletePrimarySkill_NotFound() throws Exception {
// .andExpect(MockMvcResultMatchers.status().isNotFound()); // Mock das Service, um das PrimarySkill nicht zu finden
// Mockito.when(primarySkillDetails.getPrimarySkillByPsid(1L)).thenReturn(Optional.empty());
// // Verifiziere, dass der Service nicht aufgerufen wurde
// Mockito.verify(primarySkillService, Mockito.never()).deletePrimarySkill(1L); // Führe die DELETE-Anfrage aus
// } mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill")
//} .param("pid", "1"))
.andExpect(MockMvcResultMatchers.status().isNotFound());
// Verifiziere, dass der Service nicht aufgerufen wurde
Mockito.verify(primarySkillActions, Mockito.never()).deletePrimarySkill(1L);
}
}

350
src/test/java/com/maradona/backend/controllers/api/ProjectControllerTest.java
View File

@ -1,199 +1,151 @@
//package com.maradona.backend.controllers.api; package com.maradona.backend.controllers.api;
//
//import com.maradona.backend.controllers.api.ProjectController; import com.maradona.backend.entities.Project;
//import com.maradona.backend.entities.Project; import com.maradona.backend.services.details.ProjectDetails;
//import com.maradona.backend.services.ProjectService; import com.maradona.backend.services.actions.ProjectActions;
//import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
//import org.springframework.beans.factory.annotation.Autowired; import org.mockito.Mockito;
//import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
//import org.springframework.http.MediaType; import org.springframework.boot.test.mock.mockito.MockBean;
//import org.springframework.test.web.servlet.MockMvc; import org.springframework.http.MediaType;
// import org.springframework.test.web.servlet.MockMvc;
//import java.time.LocalDate;
//import java.util.Arrays; import java.time.LocalDate;
//import java.util.Optional; import java.util.Arrays;
// import java.util.Optional;
//import static org.mockito.ArgumentMatchers.any;
//import static org.mockito.Mockito.when; import static org.mockito.ArgumentMatchers.any;
//import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; 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.status;
//import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
//
//@WebMvcTest(ProjectController.class) @WebMvcTest(ProjectController.class)
//public class ProjectControllerTest { public class ProjectControllerTest {
// // MockMvc to simulate HTTP requests to the controller
// @Autowired @Autowired
// private MockMvc mockMvc; private MockMvc mockMvc;
//
// // Mocked ProjectService to simulate service calls @MockBean
// @MockBean private ProjectDetails projectService;
// private ProjectService projectService;
// @MockBean
// @Test private ProjectActions projectActions;
// public void testGetProjectById() throws Exception {
// //Arrange: Mock an project @Test
// Project project = new Project(); public void testGetProjectById() throws Exception {
// project.setPid(1L); Project project = new Project();
// project.setName("Skillmanagementsystem erstellen"); project.setPid(1L);
// project.setStartDate(LocalDate.of(2024, 11,8)); project.setName("Skillmanagementsystem erstellen");
// project.setEndDate(LocalDate.of(2024, 11,20)); project.setStartDate(LocalDate.of(2024, 11, 8));
// project.setWorkload(12); project.setEndDate(LocalDate.of(2024, 11, 20));
// project.setDescription("Skillmanagementsystem erstellen für die Firma"); 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.getProjectByPid(1L)).thenReturn(Optional.of(project)); Mockito.when(projectService.getProjectByPid(1L)).thenReturn(Optional.of(project));
//
// //Act & Assert: Send GET request an expect a 200 OK status and JSON response mockMvc.perform(get("/api/project")
// //GET /api/project/ .param("psid", "1")
// mockMvc.perform(get("/api/project") .contentType(MediaType.APPLICATION_JSON))
// .param("id", "1") .andExpect(status().isOk())
// .contentType(MediaType.APPLICATION_JSON)) .andExpect(jsonPath("$.pid").value(1))
// .andExpect(status().isOk()) .andExpect(jsonPath("$.name").value("Skillmanagementsystem erstellen"))
// .andExpect(jsonPath("$.id").value(1)) .andExpect(jsonPath("$.startDate").value("2024-11-08"))
// .andExpect(jsonPath("$.name").value("Skillmanagementsystem erstellen")) .andExpect(jsonPath("$.endDate").value("2024-11-20"))
// .andExpect(jsonPath("$.startDate").value("2024-11-08")) .andExpect(jsonPath("$.workload").value(12))
// .andExpect(jsonPath("$.endDate").value("2024-11-20")) .andExpect(jsonPath("$.description").value("Skillmanagementsystem erstellen für die Firma"));
// .andExpect(jsonPath("$.workload").value(12)) }
// .andExpect(jsonPath("$.description").value("Skillmanagementsystem erstellen für die Firma"));
// } @Test
// public void testGetAllProjects() throws Exception {
// @Test Project project1 = new Project();
// public void testGetAllProjects() throws Exception { project1.setPid(1L);
// //Arrange: Creat a list of mock projects project1.setName("Skillmanagementsystem erstellen");
// Project project = new Project(); project1.setStartDate(LocalDate.of(2024, 11, 8));
// project.setPid(1L); project1.setEndDate(LocalDate.of(2024, 11, 20));
// project.setName("Skillmanagementsystem erstellen"); project1.setWorkload(12);
// project.setStartDate(LocalDate.of(2024, 11,8)); project1.setDescription("Skillmanagementsystem erstellen für die Firma");
// project.setEndDate(LocalDate.of(2024, 11,20));
// project.setWorkload(12); Project project2 = new Project();
// project.setDescription("Skillmanagementsystem erstellen für die Firma"); project2.setPid(2L);
// project2.setName("EAFC 25");
// Project project2 = new Project(); project2.setStartDate(LocalDate.of(2024, 11, 20));
// project2.setPid(2L); project2.setEndDate(LocalDate.of(2024, 11, 30));
// project2.setName("EAFC 25"); project2.setWorkload(2);
// project2.setStartDate(LocalDate.of(2024, 11,20)); project2.setDescription("Entwicklung von EAFC 25 für neues Spaßerlebnis");
// project2.setEndDate(LocalDate.of(2024, 11,30));
// project2.setWorkload(2); Mockito.when(projectService.getAllProjects()).thenReturn(Arrays.asList(project1, project2));
// project2.setDescription("Entwicklung von EAFC 25 für neues Spaß erlebnis");
// mockMvc.perform(get("/api/project/all")
// //Define the behavior of the mocked ProjectService: return a list of projects when requested .contentType(MediaType.APPLICATION_JSON))
// when(projectService.getAllProjects()).thenReturn(Arrays.asList(project, project2)); .andExpect(status().isOk())
// .andExpect(jsonPath("$[0].pid").value(1))
// //Act & Assert: Send GET request an expect a 200 Ok status and JSON response with the list of projects .andExpect(jsonPath("$[0].name").value("Skillmanagementsystem erstellen"))
// mockMvc.perform(get("/api/project/all") .andExpect(jsonPath("$[0].startDate").value("2024-11-08"))
// .contentType(MediaType.APPLICATION_JSON)) .andExpect(jsonPath("$[0].endDate").value("2024-11-20"))
// .andExpect(status().isOk()) .andExpect(jsonPath("$[0].workload").value(12))
// .andExpect(jsonPath("$[0].id").value(1)) .andExpect(jsonPath("$[0].description").value("Skillmanagementsystem erstellen für die Firma"))
// .andExpect(jsonPath("$[0].name").value("Skillmanagementsystem erstellen")) .andExpect(jsonPath("$[1].pid").value(2))
// .andExpect(jsonPath("$[0].startDate").value("2024-11-08")) .andExpect(jsonPath("$[1].name").value("EAFC 25"))
// .andExpect(jsonPath("$[0].endDate").value("2024-11-20")) .andExpect(jsonPath("$[1].startDate").value("2024-11-20"))
// .andExpect(jsonPath("$[0].workload").value(12)) .andExpect(jsonPath("$[1].endDate").value("2024-11-30"))
// .andExpect(jsonPath("$[0].description").value("Skillmanagementsystem erstellen für die Firma")) .andExpect(jsonPath("$[1].workload").value(2))
// .andExpect(jsonPath("$[1].id").value(2)) .andExpect(jsonPath("$[1].description").value("Entwicklung von EAFC 25 für neues Spaßerlebnis"));
// .andExpect(jsonPath("$[1].name").value("EAFC 25")) }
// .andExpect(jsonPath("$[1].startDate").value("2024-11-20"))
// .andExpect(jsonPath("$[1].endDate").value("2024-11-30")) @Test
// .andExpect(jsonPath("$[1].workload").value(2)) public void testCreateProject() throws Exception {
// .andExpect(jsonPath("$[1].description").value("Entwicklung von EAFC 25 für neues Spaß erlebnis")); Project project = new Project();
// } project.setPid(1L);
// project.setName("New Project");
//// @Test project.setStartDate(LocalDate.of(2024, 11, 10));
//// public void testGetProjectsByUserId() throws Exception { project.setEndDate(LocalDate.of(2024, 12, 10));
//// // Arrange: Mock projects for a specific user project.setWorkload(15);
//// Project project1 = new Project(); project.setDescription("A new project for testing");
//// project1.setPid(1L);
//// project1.setName("Skill Management System"); Mockito.when(projectActions.saveProject(any(Project.class))).thenReturn(project);
//// project1.setStartDate(LocalDate.of(2024, 11, 8));
//// project1.setEndDate(LocalDate.of(2024, 11, 20)); mockMvc.perform(post("/api/project")
//// project1.setWorkload(12); .contentType(MediaType.APPLICATION_JSON)
//// project1.setDescription("Create a skill management system for the company"); .content("{\"name\":\"New Project\",\"startDate\":\"2024-11-10\",\"endDate\":\"2024-12-10\",\"workload\":15,\"description\":\"A new project for testing\"}"))
//// .andExpect(status().isCreated())
//// Project project2 = new Project(); .andExpect(jsonPath("$.pid").value(1))
//// project2.setPid(2L); .andExpect(jsonPath("$.name").value("New Project"))
//// project2.setName("Project Management Tool"); .andExpect(jsonPath("$.workload").value(15))
//// project2.setStartDate(LocalDate.of(2024, 12, 1)); .andExpect(jsonPath("$.description").value("A new project for testing"));
//// project2.setEndDate(LocalDate.of(2024, 12, 15)); }
//// project2.setWorkload(10);
//// project2.setDescription("Develop a project management tool"); @Test
//// public void testUpdateProject() throws Exception {
//// Long userId = 123L; Project project = new Project();
//// project.setPid(1L);
//// // Mock the ProjectService to return projects for a specific user project.setName("Updated Project");
//// when(projectService.getProjectByPid(1L)).thenReturn(Arrays.asList(project1, project2)); project.setStartDate(LocalDate.of(2024, 11, 10));
//// project.setEndDate(LocalDate.of(2024, 12, 10));
//// // Act & Assert: Send GET request and expect a 200 OK status with the correct JSON response project.setWorkload(20);
//// mockMvc.perform(get("/api/project/from-user") project.setDescription("An updated project description");
//// .param("userId", String.valueOf(userId))
//// .contentType(MediaType.APPLICATION_JSON)) Mockito.when(projectActions.saveProject(any(Project.class))).thenReturn(project);
//// .andExpect(status().isOk())
//// .andExpect(jsonPath("$[0].id").value(1)) mockMvc.perform(put("/api/project")
//// .andExpect(jsonPath("$[0].name").value("Skill Management System")) .contentType(MediaType.APPLICATION_JSON)
//// .andExpect(jsonPath("$[1].id").value(2)) .content("{\"pid\":1,\"name\":\"Updated Project\",\"startDate\":\"2024-11-10\",\"endDate\":\"2024-12-10\",\"workload\":20,\"description\":\"An updated project description\"}"))
//// .andExpect(jsonPath("$[1].name").value("Project Management Tool")); .andExpect(status().isOk())
//// } .andExpect(jsonPath("$.pid").value(1))
// .andExpect(jsonPath("$.name").value("Updated Project"))
// @Test .andExpect(jsonPath("$.workload").value(20))
// public void testCreateProject() throws Exception { .andExpect(jsonPath("$.description").value("An updated project description"));
// // Arrange: Create a new project and set all required fields }
// Project savedProject = new Project();
// savedProject.setPid(1L); // ID setzen @Test
// savedProject.setName("New Project"); public void testDeleteProject() throws Exception {
// savedProject.setStartDate(LocalDate.of(2024, 11, 10)); Long projectId = 1L;
// savedProject.setEndDate(LocalDate.of(2024, 12, 10));
// savedProject.setWorkload(15); mockMvc.perform(delete("/api/project")
// savedProject.setDescription("A new project for testing"); .param("pid", String.valueOf(projectId))
// .contentType(MediaType.APPLICATION_JSON))
// // Mocking the saveProject method to return this specific project .andExpect(status().isNoContent());
// when(projectService.saveProject(any(Project.class))).thenReturn(savedProject);
// Mockito.verify(projectActions, Mockito.times(1)).deleteProject(projectId);
// // 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.setPid(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());
// }
//}

274
src/test/java/com/maradona/backend/controllers/api/SecondarySkillControllerTest.java
View File

@ -1,130 +1,144 @@
//package com.maradona.backend.controllers.api; package com.maradona.backend.controllers.api;
//
//import com.maradona.backend.entities.SecondarySkill; import com.maradona.backend.entities.SecondarySkill;
//import com.maradona.backend.services.SecondarySkillService; import com.maradona.backend.services.actions.SecondarySkillActions;
//import org.junit.jupiter.api.Test; import com.maradona.backend.services.details.SecondarySkillDetails;
//import org.springframework.beans.factory.annotation.Autowired; import org.junit.jupiter.api.Test;
//import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; import org.mockito.InjectMocks;
//import org.springframework.boot.test.mock.mockito.MockBean; import org.mockito.Mock;
//import org.springframework.http.MediaType; import org.mockito.Mockito;
//import org.springframework.test.web.servlet.MockMvc; import org.mockito.MockitoAnnotations;
// import org.junit.jupiter.api.BeforeEach;
//import java.util.Arrays; import org.springframework.beans.factory.annotation.Autowired;
//import java.util.Optional; import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
// import org.springframework.boot.test.mock.mockito.MockBean;
//import static org.mockito.ArgumentMatchers.any; import org.springframework.http.MediaType;
//import static org.mockito.Mockito.when; import org.springframework.test.web.servlet.MockMvc;
//import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; import 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; import java.util.Arrays;
// import java.util.Optional;
//@WebMvcTest(SecondarySkillController.class)
//public class SecondarySkillControllerTest { import static org.mockito.ArgumentMatchers.any;
// import static org.mockito.Mockito.when;
// @Autowired import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
// private MockMvc mockMvc; import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
//
// @MockBean @WebMvcTest(SecondarySkillController.class)
// private SecondarySkillService secondarySkillService; public class SecondarySkillControllerTest {
//
// @Test @Autowired
// public void testGetSecondarySkillById() throws Exception { private MockMvc mockMvc;
// SecondarySkill skill = new SecondarySkill();
// skill.setSsid(1L); @MockBean
// skill.setDescription("Java Programming"); private SecondarySkillDetails secondarySkillService;
//
// when(secondarySkillService.getSecondarySkillBySsid(1L)).thenReturn(Optional.of(skill)); @MockBean
// private SecondarySkillActions secondarySkillActions;
// mockMvc.perform(get("/api/secondary-skill")
// .param("id", "1") @BeforeEach
// .contentType(MediaType.APPLICATION_JSON)) public void setup() {
// .andExpect(status().isOk()) MockitoAnnotations.openMocks(this);
// .andExpect(jsonPath("$.ssid").value(1)) }
// .andExpect(jsonPath("$.description").value("Java Programming"));
// } @Test
// public void testGetSecondarySkillById() throws Exception {
// @Test SecondarySkill skill = new SecondarySkill();
// public void testGetAllSecondarySkills() throws Exception { skill.setSsid(1L);
// SecondarySkill skill1 = new SecondarySkill(); skill.setDescription("Java Programming");
// skill1.setSsid(1L);
// skill1.setDescription("Java Programming"); when(secondarySkillService.getSecondarySkillBySsid(1L)).thenReturn(Optional.of(skill));
//
// SecondarySkill skill2 = new SecondarySkill(); mockMvc.perform(MockMvcRequestBuilders.get("/api/secondary-skill")
// skill2.setSsid(2L); .param("ssid", "1")
// skill2.setDescription("Python Programming"); .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isOk())
// when(secondarySkillService.getAllSecondarySkills()).thenReturn(Arrays.asList(skill1, skill2)); .andExpect(jsonPath("$.ssid").value(1))
// .andExpect(jsonPath("$.description").value("Java Programming"));
// mockMvc.perform(get("/api/secondary-skill/all") }
// .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isOk()) @Test
// .andExpect(jsonPath("$[1].ssid").value(1)) public void testGetAllSecondarySkills() throws Exception {
// .andExpect(jsonPath("$[1].description").value("Java Programming")) SecondarySkill skill1 = new SecondarySkill();
// .andExpect(jsonPath("$[2].ssid").value(2)) skill1.setSsid(1L);
// .andExpect(jsonPath("$[2].description").value("Python Programming")); skill1.setDescription("Java Programming");
// }
// SecondarySkill skill2 = new SecondarySkill();
// @Test skill2.setSsid(2L);
// public void testGetSecondarySkillsByPrimarySkillId() throws Exception { skill2.setDescription("Python Programming");
// SecondarySkill skill1 = new SecondarySkill();
// skill1.setSsid(1L); when(secondarySkillService.getAllSecondarySkills()).thenReturn(Arrays.asList(skill1, skill2));
// skill1.setDescription("Data Analysis");
// mockMvc.perform(MockMvcRequestBuilders.get("/api/secondary-skill/all")
// SecondarySkill skill2 = new SecondarySkill(); .contentType(MediaType.APPLICATION_JSON))
// skill2.setSsid(2L); .andExpect(status().isOk())
// skill2.setDescription("Data Visualization"); .andExpect(jsonPath("$[0].ssid").value(1))
// .andExpect(jsonPath("$[0].description").value("Java Programming"))
// when(secondarySkillService.getSecondarySkillsByPrimarySkillId(100L)).thenReturn(Arrays.asList(skill1, skill2)); .andExpect(jsonPath("$[1].ssid").value(2))
// .andExpect(jsonPath("$[1].description").value("Python Programming"));
// mockMvc.perform(get("/api/secondary-skill/from-primary-skill") }
// .param("primarySkillId", "100")
// .contentType(MediaType.APPLICATION_JSON)) @Test
// .andExpect(status().isOk()) public void testGetSecondarySkillsByPrimarySkillId() throws Exception {
// .andExpect(jsonPath("$[1].ssid").value(1)) SecondarySkill skill1 = new SecondarySkill();
// .andExpect(jsonPath("$[1].description").value("Data Analysis")) skill1.setSsid(1L);
// .andExpect(jsonPath("$[2].ssid").value(2)) skill1.setDescription("Data Analysis");
// .andExpect(jsonPath("$[2].description").value("Data Visualization"));
// } SecondarySkill skill2 = new SecondarySkill();
// skill2.setSsid(2L);
// @Test skill2.setDescription("Data Visualization");
// public void testCreateSecondarySkill() throws Exception {
// SecondarySkill skill = new SecondarySkill(); when(secondarySkillService.getSecondarySkillsByPrimarySkillId(100L)).thenReturn(Arrays.asList(skill1, skill2));
// skill.setSsid(1L);
// skill.setDescription("Machine Learning"); mockMvc.perform(MockMvcRequestBuilders.get("/api/secondary-skill/from-primary-skill")
// .param("psid", "100")
// when(secondarySkillService.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(skill); .contentType(MediaType.APPLICATION_JSON))
// .andExpect(status().isOk())
// mockMvc.perform(post("/api/secondary-skill") .andExpect(jsonPath("$[0].ssid").value(1))
// .contentType(MediaType.APPLICATION_JSON) .andExpect(jsonPath("$[0].description").value("Data Analysis"))
// .content("{\"name\":\"Machine Learning\"}")) .andExpect(jsonPath("$[1].ssid").value(2))
// .andExpect(status().isCreated()) .andExpect(jsonPath("$[1].description").value("Data Visualization"));
// .andExpect(jsonPath("$.ssid").value(1)) }
// .andExpect(jsonPath("$.description").value("Machine Learning"));
// } @Test
// public void testCreateSecondarySkill() throws Exception {
// @Test SecondarySkill skill = new SecondarySkill();
// public void testUpdateSecondarySkill() throws Exception { skill.setSsid(1L);
// SecondarySkill updatedSkill = new SecondarySkill(); skill.setDescription("Machine Learning");
// updatedSkill.setSsid(1L);
// updatedSkill.setDescription("Advanced Machine Learning"); when(secondarySkillActions.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(skill);
//
// when(secondarySkillService.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(updatedSkill); mockMvc.perform(MockMvcRequestBuilders.post("/api/secondary-skill")
// .contentType(MediaType.APPLICATION_JSON)
// mockMvc.perform(put("/api/secondary-skill") .content("{\"description\":\"Machine Learning\"}"))
// .contentType(MediaType.APPLICATION_JSON) .andExpect(status().isCreated())
// .content("{\"ssid\":1,\"description\":\"Advanced Machine Learning\"}")) .andExpect(jsonPath("$.ssid").value(1))
// .andExpect(status().isOk()) .andExpect(jsonPath("$.description").value("Machine Learning"));
// .andExpect(jsonPath("$.ssid").value(1)) }
// .andExpect(jsonPath("$.description").value("Advanced Machine Learning"));
// } @Test
// public void testUpdateSecondarySkill() throws Exception {
// @Test SecondarySkill updatedSkill = new SecondarySkill();
// public void testDeleteSecondarySkill() throws Exception { updatedSkill.setSsid(1L);
// Long skillId = 1L; updatedSkill.setDescription("Advanced Machine Learning");
//
// mockMvc.perform(delete("/api/secondary-skill") when(secondarySkillActions.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(updatedSkill);
// .param("id", String.valueOf(skillId))
// .contentType(MediaType.APPLICATION_JSON)) mockMvc.perform(MockMvcRequestBuilders.put("/api/secondary-skill")
// .andExpect(status().isNoContent()); .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(MockMvcRequestBuilders.delete("/api/secondary-skill")
.param("ssid", String.valueOf(skillId))
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isNoContent());
}
}