test cases for service layer

src/test/java/com/nisum/Employeeinfo/dao/EmployeeDaoTest.java

+package com.nisum.Employeeinfo.dao;
+
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.r2dbc.core.DatabaseClient;
+
+@SpringBootTest
+public class EmployeeDaoTest {
+
+    @InjectMocks
+    private EmployeeDao employeeDao;
+
+    @Mock
+    private DatabaseClient databaseClient;
+
+    @Mock
+    private DatabaseClient.GenericExecuteSpec executeSpec;
+}

src/test/java/com/nisum/Employeeinfo/service/EmployeeServiceImplTest.java

+package com.nisum.Employeeinfo.service;
+
+import com.nisum.Employeeinfo.dao.EmployeeDao;
+import com.nisum.Employeeinfo.dto.EmployeeDto;
+import com.nisum.Employeeinfo.model.Employee;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.test.context.SpringBootTest;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import static org.mockito.ArgumentMatchers.any;
+
+@SpringBootTest
+public class EmployeeServiceImplTest {
+
+    @InjectMocks
+    private EmployeeServiceImpl employeeService;
+
+    @Mock
+    private EmployeeDao employeeDao;
+
+    private static final Logger log = LoggerFactory.getLogger(EmployeeServiceImplTest.class);
+
+    @Test
+    void addEmployeeTest() {
+        EmployeeDto employeeDto = new EmployeeDto("Ram", "ram@gmail.com", "IT", 50000.00);
+        Employee employee = new Employee(1, "Ram", "ram@gmail.com", "IT", 50000.00);
+
+        Mockito.when(employeeDao.saveEmployee(any(Employee.class))).thenReturn(Mono.just(employee));
+
+        StepVerifier.create(employeeService.addEmployee(Mono.just(employeeDto)))
+                .expectNextMatches(savedEmployee ->
+                        savedEmployee.getId().equals(1) &&
+                                savedEmployee.getName().equals("ram") &&
+                                savedEmployee.getEmail().equals("ram@gmail.com") &&
+                                savedEmployee.getDept().equals("IT") &&
+                                Double.compare(savedEmployee.getSal(), 50000.00) == 0)
+                .verifyComplete();
+
+        Mockito.verify(employeeDao, Mockito.times(1)).saveEmployee(any(Employee.class));
+    }
+
+    @Test
+    void getAllEmployeeTest() {
+        Employee employee1 = new Employee(1, "ram", "ram@gmail.com", "IT", 50000.00);
+        Employee employee2 = new Employee(2, "sam", "sam@gmail.com", "HR", 60000.00);
+
+        Mockito.when(employeeDao.findAllEmployee()).thenReturn(Flux.just(employee1, employee2));
+
+        StepVerifier.create(employeeService.getAllEmployee())
+                .expectNext(employee1)
+                .expectNext(employee2)
+                .verifyComplete();
+
+        Mockito.verify(employeeDao, Mockito.times(1)).findAllEmployee();
+    }
+
+    @Test
+    void getEmployeeByIdTest() {
+        Employee employee = new Employee(1, "ram", "ram@gmail.com", "IT", 50000.00);
+
+        Mockito.when(employeeDao.findEmployeeById(1)).thenReturn(Mono.just(employee));
+
+        StepVerifier.create(employeeService.getEmployeeById(1))
+                .expectNextMatches(foundEmployee ->
+                        foundEmployee.getId().equals(1) &&
+                                foundEmployee.getName().equals("ram") &&
+                                foundEmployee.getEmail().equals("ram@gmail.com") &&
+                                foundEmployee.getDept().equals("IT") &&
+                                Double.compare(foundEmployee.getSal(), 50000.00) == 0)
+                .verifyComplete();
+
+        Mockito.verify(employeeDao, Mockito.times(1)).findEmployeeById(1);
+    }
+
+    @Test
+    void updateEmployeeTest() {
+        Integer employeeId = 1;
+        Employee existingEmployee = new Employee(1, "ram", "ram@gmail.com", "IT", 50000.00);
+        EmployeeDto updatedEmployeeDto = new EmployeeDto("sam", "sam@gmail.com", "HR", 60000.00);
+        Employee updatedEmployee = new Employee(1, "sam", "sam@gmail.com", "HR", 60000.00);
+
+        Mockito.when(employeeDao.findEmployeeById(employeeId)).thenReturn(Mono.just(existingEmployee));
+        Mockito.when(employeeDao.saveEmployee(any(Employee.class))).thenReturn(Mono.just(updatedEmployee));
+
+        StepVerifier.create(employeeService.updateEmployee(employeeId, Mono.just(updatedEmployeeDto)))
+                .expectNextMatches(updatedEmp ->
+                        updatedEmp.getId().equals(1) &&
+                                updatedEmp.getName().equals("sam") &&
+                                updatedEmp.getEmail().equals("sam@gmail.com") &&
+                                updatedEmp.getDept().equals("HR") &&
+                                Double.compare(updatedEmp.getSal(), 60000.00) == 0)
+                .verifyComplete();
+
+        Mockito.verify(employeeDao, Mockito.times(1)).findEmployeeById(employeeId);
+        Mockito.verify(employeeDao, Mockito.times(1)).saveEmployee(any(Employee.class));
+    }
+
+    @Test
+    void deleteEmployeeTest() {
+        Integer employeeId = 1;
+
+        Mockito.when(employeeDao.deleteEmployeeById(employeeId)).thenReturn(Mono.empty());
+
+        StepVerifier.create(employeeService.deleteEmployee(employeeId))
+                .verifyComplete();
+
+        Mockito.verify(employeeDao, Mockito.times(1)).deleteEmployeeById(employeeId);
+    }
+
+}