Test cases for EmployeeService class methods

src/main/java/com/nisum/example/mongodb/controller/EmployeeController.java

@@ -27,7 +27,7 @@ public class EmployeeController {
     @PostMapping(path = "/create")
    @ResponseStatus(HttpStatus.CREATED)
     public Mono<Employee> create(@RequestBody Employee e) {
-        return employeeService.create(e);
+        return employeeService.insert(e);
     }
 
     /**
@@ -37,9 +37,9 @@ public class EmployeeController {
      */
     @GetMapping("/{id}")
     public ResponseEntity<Mono<Employee>> findById(@PathVariable("id") Integer id) {
-        Mono<Employee> e = employeeService.findById(id);
-        HttpStatus status = e != null ? HttpStatus.OK : HttpStatus.NOT_FOUND;
-        return new ResponseEntity<Mono<Employee>>(e, status);
+        Mono<Employee> emp = employeeService.fetchById(id);
+        HttpStatus status = emp!=null ?HttpStatus.OK:HttpStatus.NOT_FOUND;
+        return new ResponseEntity<Mono<Employee>>(emp, status);
     }
 
     /**
@@ -49,8 +49,7 @@ public class EmployeeController {
      */
     @GetMapping("/name/{name}")
     public Flux<Employee> findByName(@PathVariable("name") String name) {
-
-        return employeeService.findByName(name);
+        return employeeService.fetchByName(name);
     }
 
     /**
@@ -59,19 +58,19 @@ public class EmployeeController {
      */
     @GetMapping(value = "", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
     public Flux<Employee> findAll() {
-        Flux<Employee> emps = employeeService.findAll();
+        Flux<Employee> emps = employeeService.fetchAll();
         return emps;
     }
 
     /**
-     * PUT method to do update of record
-     * @param e
+     * PUT method to do modify of record
+     * @param emp
      * @return Mono
      */
     @PutMapping("/update")
     @ResponseStatus(HttpStatus.OK)
-    public Mono<Employee> update(@RequestBody Employee e) {
-        return employeeService.update(e);
+    public Mono<Employee> update(@RequestBody Employee emp) {
+        return employeeService.modify(emp);
     }
 
     /**
@@ -81,8 +80,8 @@ public class EmployeeController {
      */
     @DeleteMapping("/delete/{id}")
     @ResponseStatus(HttpStatus.OK)
-    public void delete(@PathVariable("id") Integer id) {
-        employeeService.delete(id).subscribe();
+    public void deleteById(@PathVariable("id") Integer id) {
+        employeeService.removeById(id);
     }
 
 }

src/main/java/com/nisum/example/mongodb/model/Employee.java

 package com.nisum.example.mongodb.model;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Scope;
 import org.springframework.context.annotation.ScopedProxyMode;
 import org.springframework.data.annotation.Id;
@@ -18,14 +17,12 @@ import org.springframework.data.mongodb.core.mapping.Document;
 @Document
 @Data
 @NoArgsConstructor
-@RequiredArgsConstructor
+@AllArgsConstructor
 public class Employee {
     @Id
     private Integer id;
 
-    @NonNull
    private String name;
-    @NonNull
     private Long salary;
 
 

src/main/java/com/nisum/example/mongodb/service/EmployeeServiceImpl.java

@@ -7,8 +7,6 @@ import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
-import java.time.Duration;
-
 /**
  *Service class having methods for CURD operations
  * Methods having Mono<T> and Flux<T> as return types
@@ -21,12 +19,12 @@ public class EmployeeServiceImpl implements IEmployeeService {
 
     /**
      * perform create operation
-     * @param e
+     * @param emp
      * @return Mono
      */
     @Override
-    public Mono<Employee> create(Employee e) {
-        return employeeRepository.save(e);
+    public Mono<Employee> insert(Employee emp) {
+        return employeeRepository.save(emp);
     }
 
     /**
@@ -35,17 +33,19 @@ public class EmployeeServiceImpl implements IEmployeeService {
      * @return Mono
      */
     @Override
-    public Mono<Employee> findById(Integer id) {
+    public Mono<Employee> fetchById(Integer id) {
         return employeeRepository.findById(id);
+
     }
 
+
     /**
      * perform fetch operation based on name
      * @param name
      * @return Flux
      */
     @Override
-    public Flux<Employee> findByName(String name) {
+    public Flux<Employee> fetchByName(String name) {
         return employeeRepository.findByName(name);
     }
 
@@ -54,27 +54,33 @@ public class EmployeeServiceImpl implements IEmployeeService {
      * @return Flux
      */
     @Override
-    public Flux<Employee> findAll() {
-        return employeeRepository.findAll().delayElements(Duration.ofSeconds(1));
+    public Flux<Employee> fetchAll() {
+        return employeeRepository.findAll()
+                /*.delayElements(Duration.ofSeconds(1)).map(
+                        employee -> {
+                            employee.setSalary(4000L);
+                            System.out.println(employee);
+                            return employee;
+                        })*/;
     }
 
     /**
-     * perform update of object
-     * @param e
+     * perform modify of object
+     * @param emp
      * @return updated object of type Mono
      */
     @Override
-    public Mono<Employee> update(Employee e) {
-        return employeeRepository.save(e);
+    public Mono<Employee> modify(Employee emp) {
+        return employeeRepository.save(emp);
     }
 
     /**
-     * perform delete based on id
+     * perform removeById based on id
      * @param id
      * @return Mono
      */
     @Override
-    public Mono<Void> delete(Integer id) {
+    public Mono<Void> removeById(Integer id) {
         return employeeRepository.deleteById(id);
     }
 }

src/main/java/com/nisum/example/mongodb/service/IEmployeeService.java

@@ -6,10 +6,10 @@ import reactor.core.publisher.Mono;
 
 public interface IEmployeeService {
 
-    Mono<Employee> create(Employee e);
-    Mono<Employee> findById(Integer id);
-    Flux<Employee> findByName(String name);
-    Flux<Employee> findAll();
-    Mono<Employee> update(Employee e);
-    Mono<Void> delete(Integer id);
+    Mono<Employee> insert(Employee emp);
+    Mono<Employee> fetchById(Integer id);
+    Flux<Employee> fetchByName(String name);
+    Flux<Employee> fetchAll();
+    Mono<Employee> modify(Employee emp);
+    Mono<Void> removeById(Integer id);
 }

src/test/java/com/nisum/example/mongodb/controller/EmployeeControllerTest.java

@@ -45,7 +45,7 @@ public class EmployeeControllerTest {
         webTestClient.post()
                 .uri("/create")
                 .contentType(MediaType.APPLICATION_JSON)
-                .body(BodyInserters.fromObject(employee))
+                .body(BodyInserters.fromValue(employee))
                 .exchange()
                 .expectStatus().isCreated();
 
@@ -59,20 +59,21 @@ public class EmployeeControllerTest {
         employee.setName("SAM");
         employee.setSalary(1500L);
 
-        Mockito.when(repository.findById(employee.getId()))
+        Mockito.when(repository.findById(1))
                 .thenReturn(Mono.just(employee));
 
         webTestClient.get()
-                .uri("/{id}",employee.getId())
+                .uri("/{id}",1)
                 .exchange()
                 .expectStatus().isOk()
                 .expectBody()
                 .jsonPath("$.name").isNotEmpty()
-                .jsonPath("$.id").isEqualTo(employee.getId())
+                .jsonPath("$.id").isEqualTo(1)
                 .jsonPath("$.name").isEqualTo("SAM")
                 .jsonPath("$.salary").isEqualTo(1500);
 
-        Mockito.verify(repository,times(1)).findById(employee.getId());
+        Mockito.verify(repository,times(1))
+                .findById(1);
     }
 
     @Test
@@ -98,7 +99,8 @@ public class EmployeeControllerTest {
                 .uri("/name/{name}","SAM")
                 .exchange()
                 .expectStatus().isOk()
-                .expectBodyList(Employee.class);
+                .expectBodyList(Employee.class)
+                .hasSize(2);
 
         Mockito.verify(repository,times(1)).findByName("SAM");
     }
@@ -130,6 +132,24 @@ public class EmployeeControllerTest {
         Mockito.verify(repository,times(1)).findAll();
     }
 
+    @Test
+    void testUpdateEmployee(){
+        Employee employee=new Employee();
+        employee.setId(3);
+        employee.setName("SYED");
+        employee.setSalary(1800L);
+
+        Mockito.when(repository.save(employee)).thenReturn(Mono.just(employee));
+
+        webTestClient.put()
+                .uri("/update")
+                .contentType(MediaType.APPLICATION_JSON)
+                .body(BodyInserters.fromValue(employee))
+                .exchange()
+                .expectStatus().isOk();
+
+        Mockito.verify(repository,times(1)).save(employee);
+    }
 
     @Test
     void testDeleteEmployee()

src/test/java/com/nisum/example/mongodb/service/EmployeeServiceTest.java

+package com.nisum.example.mongodb.service;
+
+import com.nisum.example.mongodb.model.Employee;
+import com.nisum.example.mongodb.repository.EmployeeRepository;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@SpringBootTest
+public class EmployeeServiceTest {
+
+    @Autowired
+    private IEmployeeService employeeService;
+
+    @MockBean
+    private EmployeeRepository employeeRepository;
+
+    @Test
+    void testInsertEmployee(){
+        Employee employee=new Employee(101,"SYED",1500L);
+        Mono<Employee> employeeMono=Mono.just(employee);
+        Mockito.when(employeeRepository.save(employee)).thenReturn(employeeMono);
+        assertEquals(employeeMono,employeeService.insert(employee));
+
+    }
+
+    @Test
+    void testEmployeeFetchById(){
+        Employee employee=new Employee(101,"SYED",1500L);
+        Mono<Employee> employeeMono=Mono.just(employee);
+        Mockito.when(employeeRepository.findById(101)).thenReturn(employeeMono);
+        assertEquals(employeeMono,employeeService.fetchById(101));
+
+    }
+
+    @Test
+    void testEmployeeFetchByName(){
+        Employee employee=new Employee(101,"SYED",1500L);
+        Flux<Employee> employeeFlux=Flux.just(employee);
+        Mockito.when(employeeRepository.findByName("SYED")).thenReturn(employeeFlux);
+        assertEquals(employeeFlux,employeeService.fetchByName("SYED"));
+
+    }
+
+    @Test
+    void testFetchAllEmployees(){
+        Employee employee=new Employee(101,"SYED",1500L);
+        Flux<Employee> employeeFlux=Flux.just(employee);
+        Mockito.when(employeeRepository.findAll()).thenReturn(employeeFlux);
+        assertEquals(employeeFlux,employeeService.fetchAll());
+    }
+
+    @Test
+    void testModifyEmployee(){
+        Employee employee=new Employee(101,"SYED",1500L);
+        Mono<Employee> employeeMono=Mono.just(employee);
+        Mockito.when(employeeRepository.save(employee)).thenReturn(employeeMono);
+        assertEquals(employeeMono,employeeService.modify(employee));
+    }
+
+    @Test
+    void testRemoveByIdEmployee(){
+        Mono<Void> voidMono=Mono.empty();
+        Mockito.when(employeeRepository.deleteById(1)).thenReturn(voidMono);
+        assertEquals(voidMono,employeeService.removeById(1));
+
+    }
+
+
+}