refactor: update EmployeeDaoImplTest to use isolated test data and setup/teardown for reliable CRUD and search tests

Author: pitzzahh

src/test/java/dao/impl/EmployeeDaoImplTest.java

@@ -1,17 +1,22 @@
 package dao.impl;
 
 import dao.EmployeeDao;
+import dao.PositionDao;
+import dao.TeamDao;
+import db.ConnectionManager;
 import entities.Employee;
-import entities.enums.CivilStatus;
 import entities.enums.EmployeeFetchType;
-import entities.enums.Gender;
-import entry.HumanResourceInformationSystem;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import java.time.LocalDate;
+import lombok.extern.slf4j.Slf4j;
+import org.h2.Driver;
+import org.h2.tools.RunScript;
+import org.junit.jupiter.api.*;
+
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
@@ -21,65 +26,95 @@
  * Test class for EmployeeDaoImpl.
  * Tests CRUD operations and search functionalities.
  */
+@Slf4j
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class EmployeeDaoImplTest {
 
     private EmployeeDao employeeDao;
-
-    @BeforeEach
-    void setUp() {
-        // Initialize the DAO
+    private PositionDao positionDao;
+    private TeamDao teamDao;
+
+    @BeforeAll
+    void setUpDatabase() {
+        ConnectionManager.setEnvFile(".env.test");
+        ConnectionManager.setDriver(Driver.load());
+        try (Connection conn = ConnectionManager.getConnection()) {
+            RunScript.execute(conn, new InputStreamReader(Objects.requireNonNull(EmployeeDaoImplTest.class.getClassLoader().getResourceAsStream("hris_h2.sql"))));
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+        // Initialize DAOs
+        positionDao = new PositionDaoImpl();
+        teamDao = new TeamDaoImpl();
         employeeDao = new EmployeeDaoImpl();
     }
 
+    @AfterAll
     @AfterEach
-    void tearDown() {
-        // Clean up if necessary
+    void cleanUp() {
+        try (Connection conn = ConnectionManager.getConnection();
+             Statement stmt = conn.createStatement()) {
+            //noinspection SqlWithoutWhere
+            stmt.execute("DELETE FROM employees");
+            //noinspection SqlWithoutWhere
+            stmt.execute("DELETE FROM positions");
+            //noinspection SqlWithoutWhere
+            stmt.execute("DELETE FROM teams");
+        } catch (Exception e) {
+            log.error(e.getMessage(), e);
+        }
     }
 
     @Test
     void testCreateEmployee() {
-        Employee employee = Employee.builder()
-                .employeeNumber(9999)
-                .positionId(1)
-                .teamId(1)
-                .firstName("Test")
-                .middleName("User")
-                .lastName("Example")
-                .contactNumber("1234567890")
-                .gender(Gender.MALE)
-                .dateOfBirth(LocalDate.of(1990, 1, 1))
-                .civilStatus(CivilStatus.SINGLE)
-                .build();
-
-        CompletableFuture<Integer> future = employeeDao.createEmployee(employee);
-        Integer id = future.join();
-
-        assertNotNull(id);
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        int id = EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", "Example", 9999);
+
         assertTrue(id > 0);
     }
 
     @Test
     void testGetEmployeeById() {
-        // Assuming an employee with ID 1 exists
-        CompletableFuture<Optional<Employee>> future = employeeDao.getEmployeeById(1);
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        int id = EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", 1001);
+
+        // Now test get
+        CompletableFuture<Optional<Employee>> future = employeeDao.getEmployeeById(id);
         Optional<Employee> employee = future.join();
 
         assertTrue(employee.isPresent());
-        assertEquals(1, employee.get().getId());
+        assertEquals(id, employee.get().getId());
     }
 
     @Test
     void testGetEmployeeByEmployeeNumber() {
-        // Assuming an employee with number 1001 exists
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", 1001);
+
+        // Now test get
         CompletableFuture<Optional<Employee>> future = employeeDao.getEmployeeByEmployeeNumber(1001);
-        Optional<Employee> employee = future.join();
+        Optional<Employee> retrieved = future.join();
 
-        assertTrue(employee.isPresent());
-        assertEquals(1001, employee.get().getEmployeeNumber());
+        assertTrue(retrieved.isPresent());
+        assertEquals(1001, retrieved.get().getEmployeeNumber());
     }
 
     @Test
     void testGetEmployees() {
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", 1001);
+
         CompletableFuture<Map<Integer, Employee>> future = employeeDao.getEmployees();
         Map<Integer, Employee> employees = future.join();
 
@@ -89,27 +124,43 @@ void testGetEmployees() {
 
     @Test
     void testGetEmployeesByEmployeeNumberLike() {
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", 1001);
+
         CompletableFuture<Map<Integer, Employee>> future = employeeDao.getEmployeesByEmployeeNumberLike("100");
         Map<Integer, Employee> employees = future.join();
 
         assertNotNull(employees);
-        // Assuming there are employees with numbers starting with 100
         assertFalse(employees.isEmpty());
     }
 
     @Test
     void testGetEmployeesByNameLike() {
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee with "John" in name
+        EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "John", "Doe", 2001);
+
         CompletableFuture<Map<Integer, Employee>> future = employeeDao.getEmployeesByNameLike("John");
         Map<Integer, Employee> employees = future.join();
 
         assertNotNull(employees);
-        // Assuming there are employees with name containing "John"
+        assertFalse(employees.isEmpty());
     }
 
     @Test
     void testUpdateEmployeeByEmployeeId() {
-        // Assuming an employee with ID 1 exists
-        Optional<Employee> optionalEmployee = employeeDao.getEmployeeById(1).join();
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        int id = EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", 1001);
+
+        Optional<Employee> optionalEmployee = employeeDao.getEmployeeById(id).join();
         assertTrue(optionalEmployee.isPresent());
 
         Employee employee = optionalEmployee.get();
@@ -121,14 +172,19 @@ void testUpdateEmployeeByEmployeeId() {
         assertTrue(result);
 
         // Verify update
-        Optional<Employee> updatedEmployee = employeeDao.getEmployeeById(1).join();
+        Optional<Employee> updatedEmployee = employeeDao.getEmployeeById(id).join();
         assertTrue(updatedEmployee.isPresent());
         assertEquals("UpdatedName", updatedEmployee.get().getFirstName());
     }
 
     @Test
     void testSoftDeleteEmployeeByEmployeeNumber() {
-        // Assuming an employee with number 9999 was created in create test
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", "Example", 9999);
+
         CompletableFuture<Boolean> future = employeeDao.softDeleteEmployeeByEmployeeNumber(9999);
         Boolean result = future.join();
 
@@ -142,10 +198,16 @@ void testSoftDeleteEmployeeByEmployeeNumber() {
 
     @Test
     void testCountEmployees() {
+        int positionId = PositionTestUtils.createPosition(positionDao, "Manager", 50000.0);
+        int teamId = TeamTestUtils.createTeam(teamDao, "Development");
+
+        // Create a test employee
+        EmployeeTestUtils.createEmployee(employeeDao, positionId, teamId, "Test", "User", 1001);
+
         CompletableFuture<Integer> future = employeeDao.countEmployees();
         Integer count = future.join();
 
         assertNotNull(count);
-        assertTrue(count >= 0);
+        assertTrue(count > 0);
     }
 }