Open in app

Sign in

Write

Sign in

How to write junit test case with mokito for spring boot.

Sanjay Singh
4 min readDec 18, 2022

controller ,service, and repository and DTO

JaCoCo for Java Code Coverage with exclude some package

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>

 <groupId>com.netapp.spa</groupId>
 <artifactId>spa-svc</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <packaging>jar</packaging>

 <name>spa-svc</name>
 <description>SPA Service</description>

 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.7.4</version>
  <relativePath />
  <!-- lookup parent from repository -->
 </parent>

 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  <java.version>11</java.version>
  <finalName>${project.artifactId}-${project.version}</finalName>
  <maven.compiler.source>${java.version}</maven.compiler.source>
  <maven.compiler.target>${java.version}</maven.compiler.target>
  <!-- <jackson.version>2.10.1</jackson.version> -->
  <!-- <log4j2.version>2.17.0</log4j2.version> -->
 </properties>


 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- <dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.17</version>
  </dependency> -->
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-test-autoconfigure</artifactId>
   <scope>test</scope>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
   <optional>true</optional>
  </dependency>
  <dependency>
   <groupId>com.oracle.database.jdbc</groupId>
   <artifactId>ojdbc8</artifactId>
   <scope>runtime</scope>
  </dependency>

  <dependency>
   <groupId>com.oracle.database.jdbc.debug</groupId>
   <artifactId>ojdbc6dms_g</artifactId>
   <version>11.2.0.4</version>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <optional>true</optional>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
   <scope>runtime</scope>
   <optional>true</optional>
  </dependency>
  <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-sleuth</artifactId>
   <version>3.1.3</version>
  </dependency>
 </dependencies>

 <build>
  <finalName>${finalName}</finalName>
  <plugins>
   <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
   </plugin>

   <plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.5</version>
    <configuration>
     <excludes>
      <exclude>com/netapp/spa/util/*</exclude>
      <exclude>com/netapp/spa/dto/*</exclude>
     </excludes>
    </configuration>
    <executions>
     <execution>
      <goals>
       <goal>prepare-agent</goal>
      </goals>
     </execution>

     <!-- attached to Maven test phase -->
     <execution>
      <id>report</id>
      <phase>test</phase>
      <goals>
       <goal>report</goal>
      </goals>
     </execution>
    </executions>
   </plugin>
  </plugins>
 </build>
</project>

controller

import static org.mockito.Mockito.when;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.netapp.spa.dto.SpaPDCSearchRequest;
import com.netapp.spa.dto.SpaPDCSearchResponse;
import com.netapp.spa.dto.SpaSalesRepRequest;
import com.netapp.spa.dto.SpaSalesRepResponse;
import com.netapp.spa.dto.SpaSearchOrdersRequest;
import com.netapp.spa.dto.SpaSearchOrdersResponse;
import com.netapp.spa.dto.SpaSiteSearchRequest;
import com.netapp.spa.dto.SpaSiteSearchResponse;
import com.netapp.spa.service.CustomerService;
import com.netapp.spa.service.OrderService;
import com.netapp.spa.service.SalesRepService;
import com.netapp.spa.service.SiteService;
import com.netapp.spa.util.Utility;

@WebMvcTest(value = SpaController.class)
public class SpaControllerTest {

 @Autowired
 MockMvc mockMvc;

 @MockBean
 OrderService orderService;

 @MockBean
 CustomerService customerService;

 @MockBean
 SiteService siteService;

 @MockBean
 SalesRepService salesRepService;

 public static String asJsonString(final Object obj) {
  try {
   return new ObjectMapper().writeValueAsString(obj);
  } catch (Exception e) {
   throw new RuntimeException(e);
  }
 }

 @Test
 public void searchOrders_Test_Success() throws Exception {
  Utility util = new Utility();
  SpaSearchOrdersRequest request = util.test_SpaSearchRequest();
  SpaSearchOrdersResponse responseData = util.test_SpaSearchOrdersResponse();
  when(orderService.searchOrders(request)).thenReturn(responseData);
  mockMvc.perform(MockMvcRequestBuilders.post("/v1/getOrders").content(asJsonString(request))
    .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON));
 }

 @Test
 public void pdcSearch_Test_Success() throws Exception {
  Utility util = new Utility();
  SpaPDCSearchRequest request = util.pdcRequest();
  SpaPDCSearchResponse responseData = util.responseSpaPDC();
  when(customerService.searchPdc(request)).thenReturn(responseData);
  mockMvc.perform(MockMvcRequestBuilders.post("/v1/findCustomer").content(asJsonString(request))
    .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON));
 }

 @Test
 public void searchSite_Test_Success() throws Exception {
  Utility util = new Utility();
  SpaSiteSearchRequest request = util.requestSpaSite();
  SpaSiteSearchResponse responseData = util.responseSpaSite();
  when(siteService.searchSite(request)).thenReturn(responseData);
  mockMvc.perform(MockMvcRequestBuilders.post("/v1/findSite").content(asJsonString(request))
    .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON));
 }

 @Test
 public void searchSalesRep_Test_Success() throws Exception {
  Utility util = new Utility();
  SpaSalesRepRequest request = util.requestSpaSales();
  SpaSalesRepResponse responseData = util.responseSpaSales();
  when(salesRepService.searchSalesRep(request)).thenReturn(responseData);
  mockMvc.perform(MockMvcRequestBuilders.post("/v1/findSalesRep").content(asJsonString(request))
    .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON));
 }

}

service

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import com.netapp.spa.dto.SpaSiteSearchRequest;
import com.netapp.spa.dto.SpaSiteSearchResponse;
import com.netapp.spa.repository.SiteRepositoryImpl;
import com.netapp.spa.util.Utility;

@ExtendWith(MockitoExtension.class)
public class SiteService_Test {

 @InjectMocks
 SiteServiceImpl siteService;

 @Mock
 SiteRepositoryImpl siteRepository;

 @Test
 public void searchOrdersTest() {
  Utility util = new Utility();
  SpaSiteSearchRequest request = util.requestSpaSite();
  SpaSiteSearchResponse responseData = util.responseSpaSite();
  when(siteRepository.searchSite(request)).thenReturn(responseData);
  SpaSiteSearchResponse resp = siteService.searchSite(request);
  assertEquals("8222915", resp.getSiteDetails().get(0).getCustomerHierKey());

 }

}
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import com.netapp.spa.dto.SpaPDCSearchRequest;
import com.netapp.spa.dto.SpaPDCSearchResponse;
import com.netapp.spa.repository.CustomerRepositoryImpl;
import com.netapp.spa.util.Utility;

@ExtendWith(MockitoExtension.class)
public class CustomerService_Test {
 
 
 @InjectMocks
 CustomerServiceImpl customerService;

 @Mock
 CustomerRepositoryImpl customerRepository;
 
 @Test
 public void searchOrdersTest() {
  Utility util = new Utility();
  SpaPDCSearchRequest request = util.pdcRequest();
  SpaPDCSearchResponse responseData = util.responseSpaPDC();
  when(customerRepository.searchPdc(request)).thenReturn(responseData);
  SpaPDCSearchResponse resp = customerService.searchPdc(request);
  assertEquals("SIEMENS AG", resp.getPDCForComm().get(0).getNagp());

 }

repo

import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;

import com.netapp.spa.dto.SpaSiteSearchRequest;
import com.netapp.spa.util.Utility;

import oracle.jdbc.OracleConnection;

@ExtendWith(MockitoExtension.class)
public class SiteRepositoryTest {

 @InjectMocks
 SiteRepository siteRepository = new SiteRepositoryImpl();

 @Mock
 DataSource datasource;

 @Mock
 Connection connection;

 @Mock
 OracleConnection con;

 @Mock
 CallableStatement callStmt;

 @Mock
 ResultSet cursor;

 @Mock
 private JdbcTemplate jdbcTemplate;

 @Test
 public void searchOrdersTest_Success_test() throws SQLException {
  Utility util = new Utility();
  SpaSiteSearchRequest request = util.requestSpaSite();
  when(jdbcTemplate.getDataSource()).thenReturn(datasource);
  when(datasource.getConnection()).thenReturn(connection);
  when(connection.unwrap(OracleConnection.class)).thenReturn(con);
  when(con.prepareCall(anyString())).thenReturn(callStmt);
  when((ResultSet) callStmt.getObject(4)).thenReturn(cursor);
  when(cursor.next()).thenReturn(true).thenReturn(false);
  Assertions.assertNotNull(siteRepository.searchSite(request));

 }

 @Test
 public void shouldReturnDatasourceConnection() throws SQLException {

  when(datasource.getConnection()).thenReturn(connection);
  if (connection != null) {
   con = connection.unwrap(OracleConnection.class);
  }
  Connection actual = datasource.getConnection();

  assertSame(connection, actual);
 }

 @Test
 public void searchOrdersTest_Exception_test() {

  SpaSiteSearchRequest requests = new SpaSiteSearchRequest();
  try {
   when(siteRepository.searchSite(requests));
   fail();
  } catch (NullPointerException ex) {
   assertTrue(ex instanceof NullPointerException);
  }

 }

 @Test
 public void searchOrdersTest_Exception_test1() throws SQLException {
  Utility util = new Utility();
  SpaSiteSearchRequest request = util.requestSpaSite();
  when(jdbcTemplate.getDataSource()).thenReturn(datasource);
  when(datasource.getConnection()).thenReturn(connection);
  when(connection.unwrap(OracleConnection.class)).thenReturn(con);
  when(con.prepareCall(anyString())).thenReturn(callStmt);
  when((ResultSet) callStmt.getObject(4)).thenThrow(new NullPointerException("Error occurred"));
  Assertions.assertNotNull(siteRepository.searchSite(request));

 }

}
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.concurrent.ConcurrentHashMap;

import javax.sql.DataSource;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;

import com.netapp.spa.dto.SoHeader;
import com.netapp.spa.dto.SpaSearchOrdersRequest;
import com.netapp.spa.util.Utility;

import oracle.jdbc.OracleConnection;

@ExtendWith(MockitoExtension.class)
public class OrderRepositoryTest {

 @InjectMocks
 OrderRepository orderRepository = new OrderRepositoryImpl();

 @Mock
 DataSource datasource;
 @Mock
 Connection connection;
 @Mock
 OracleConnection con;
 @Mock
 CallableStatement callStmt;
 @Mock
 ResultSet cursor;

 @Mock
 private JdbcTemplate jdbcTemplate;

 @Mock
 ConcurrentHashMap<String, SoHeader> soHeaderMap;

 @Test
 public void searchOrdersTest_Success_test5() throws SQLException {
  Utility util = new Utility();
  SpaSearchOrdersRequest request = util.spaSearchRequest();
  when(jdbcTemplate.getDataSource()).thenReturn(datasource);
  when(datasource.getConnection()).thenReturn(connection);
  when(connection.unwrap(OracleConnection.class)).thenReturn(con);
  when(con.prepareCall(anyString())).thenReturn(callStmt);
  when(callStmt.getString(5)).thenReturn("SUCCESS");
  when((ResultSet) callStmt.getObject(1)).thenReturn(cursor);
  when(cursor.next()).thenReturn(true).thenReturn(false);
  Assertions.assertNotNull(orderRepository.searchOrdersFull(request));

 }

 @Test
 public void searchOrdersTest_fail_test4() throws SQLException {
  Utility util = new Utility();
  SpaSearchOrdersRequest request = util.spaSearchRequest();
  when(jdbcTemplate.getDataSource()).thenReturn(datasource);
  when(datasource.getConnection()).thenReturn(connection);
  when(connection.unwrap(OracleConnection.class)).thenReturn(con);
  when(con.prepareCall(anyString())).thenReturn(callStmt);
  when(callStmt.getString(5)).thenReturn(null).thenThrow(new NullPointerException("Error occurred"));
  Assertions.assertNotNull(orderRepository.searchOrdersFull(request));

 }

 @Test
 public void searchOrdersTest_fail_test5() throws SQLException {
  Utility util = new Utility();
  SpaSearchOrdersRequest request = util.spaSearchRequest();


   when(jdbcTemplate.getDataSource()).thenReturn(datasource);
   when(datasource.getConnection()).thenReturn(connection);
   when(connection.unwrap(OracleConnection.class)).thenReturn(con);
   when(con.prepareCall(anyString())).thenReturn(callStmt);
   when(callStmt.getString(5)).thenReturn("SUCCESS");
   when((ResultSet) callStmt.getObject(1)).thenReturn(cursor);
   when(cursor.next()).thenReturn(true).thenReturn(false);
   // when(soHeaderMap.get("2")).thenReturn(null);
   Assertions.assertNotNull(orderRepository.searchOrdersFull(request));
 }

}

DTO

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;

import java.io.IOException;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
public class ChannelOnOrderTest {

 @InjectMocks
 ChannelOnOrder account;
 @InjectMocks
 ChannelsSalesRepForComm channelsSalesRepForComm;
 @InjectMocks
 ConsolidatorOnOrder consolidatorOnOrder;
 @InjectMocks
 DemandDriverOnOrder DemandDriverOnOrder;
 @InjectMocks
 AccountOnOrder AccountOnOrder;
 @InjectMocks
 DirectSalesRepForComm DirectSalesRepForComm;
 @InjectMocks
 DistiOnOrder DistiOnOrder;
 @InjectMocks
 EnrichmentAttributes EnrichmentAttributes;
 @InjectMocks
 Error Error;
 @InjectMocks
 Errors Errors;

 @InjectMocks
 ForWhomeOnOrder ForWhomeOnOrder;
 @InjectMocks
 GoToMarketChannelParty GoToMarketChannelParty;
 @InjectMocks
 LegacyAoo LegacyAoo;
 @InjectMocks
 LegacyCoo LegacyCoo;
 @InjectMocks
 LegacyCoo1 LegacyCoo1;
 @InjectMocks
 LegacyData LegacyData;

 @InjectMocks
 LegacyDoo LegacyDoo;
 @InjectMocks
 OverlaySalesRepForComm OverlaySalesRepForComm;

 @InjectMocks
 ValueAddPartner1OnOrder ValueAddPartner1OnOrder;
 @InjectMocks
 ValueAddPartner2OnOrder ValueAddPartner2OnOrder;
 @InjectMocks
 RepsCommRate RepsCommRate;

 @InjectMocks
 Party Party;

 @InjectMocks
 SalesCreditFlagDtl SalesCreditFlagDtl;
 @InjectMocks
 SalesHierarchyNode SalesHierarchyNode;
 @InjectMocks
 SalesRepByDate SalesRepByDate;
 @InjectMocks
 SalesRepDetails SalesRepDetails;
 @InjectMocks
 SiteDetails SiteDetails;
 @InjectMocks
 PDCForComm PDCForComm;


 @Test
 public void object_Test() throws IOException {
  assertNotNull(new PDCForComm());
  assertNotNull(new AccountOnOrder());
  assertNotNull(new ChannelsSalesRepForComm());
  assertNotNull(new ConsolidatorOnOrder());
  assertNotNull(new DemandDriverOnOrder());
  assertNotNull(new AccountOnOrder());
  assertNotNull(new DirectSalesRepForComm());
  assertNotNull(new DistiOnOrder());
}
Spring Boot
Mokito
Junit
Jupiter
Java

--

--

Sanjay Singh

Written by Sanjay Singh

115 Followers

Java||Spring-Boot|| Micro services Application developer|| INDIA

Help

Status

About

Careers

Blog

Privacy

Terms

Text to speech

Teams