Hive and Impala query result not matching [timestamp] - hadoop

I'm working on a code where we are removing impala connection to hive beeline. changes are working as we expected. but when we try to query some data using impala , it came up with some additional timestamp with the date.
Sample Query: select cob_date from xxx_table where cob_date='2022-03-20';
outcome of the above query in impala is : 2022-03-20 05:00:00
but usually it will return like : 2022-03-20 00:00:00
but the same query giving proper response when try from hive : 2022-03-20 00:00:00
can anyone help me to understand whats going on here.
Thanks in advance .
package com.rest;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.rest.controller.PersonController;
import com.rest.entity.Person;
import com.rest.repository.PersonRepository;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.hamcrest.Matchers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
#RunWith(MockitoJUnitRunner.class)
public class PersonControllerTest {
private MockMvc mockMvc;
ObjectMapper mapper = new ObjectMapper();
ObjectWriter writer = mapper.writer();
#Mock
private PersonRepository personRepository;
#InjectMocks
private PersonController personController;
Person person1 = new Person(1, "Arun", "Ammasai", "aj.amsi#email.com");
Person person2 = new Person(2, "Nancy", "ArulRaj", "nancymaria#email.com");
Person person3 = new Person(3, "Jack", "Daniel", "jack.daniel#email.com");
#Before
public void init() {
MockitoAnnotations.initMocks(this);
this.mockMvc = MockMvcBuilders.standaloneSetup(personController).build();
}
#Test
public void getAllSuccess() throws Exception {
List<Person> persons = Arrays.asList(person1, person2, person3);
Mockito.when(personRepository.findAll()).thenReturn(persons);
mockMvc.perform(MockMvcRequestBuilders.get("/getall")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$", hasSize(3)))
.andExpect(jsonPath("$[2].firstName", is("Jack")));
}
#Test
public void getByIdSuccess() throws Exception {
Mockito.when(personRepository.findById(person1.getId())).thenReturn(Optional.of(person1));
mockMvc.perform(MockMvcRequestBuilders.get("/findbyId/1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(jsonPath("$", notNullValue()))
.andExpect(jsonPath("$.firstName", is("Arun")));
}
#Test
public void createPerson_Success() throws Exception {
Person person = Person.builder().firstName("Arun").lastName("Amsi").email("test#gmail.com").build();
Mockito.when(personRepository.save(person)).thenReturn(person);
String content = writer.writeValueAsString(person);
MockHttpServletRequestBuilder request = MockMvcRequestBuilders.post("/addperson")
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON)
.content(content);
mockMvc.perform(request)
.andExpect(status().isOk())
.andExpect(jsonPath("$", notNullValue()))
.andExpect(jsonPath("$.firstName", is("Arun")));
}
#Test
public void updatePerson_Success() throws Exception {
Person person = Person.builder().firstName("Arun").lastName("Amsi").email("test#gmail.com").build();
Mockito.when(personRepository.findById(person.getId())).thenReturn(Optional.of(person));
Mockito.when(personRepository.save(person)).thenReturn(person);
String content = writer.writeValueAsString(person);
MockHttpServletRequestBuilder request = MockMvcRequestBuilders.put("/updateperson")
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON)
.content(content);
mockMvc.perform(request).andExpect(status().isOk())
.andExpect(jsonPath("$", notNullValue()))
.andExpect(jsonPath("$.firstName", is("Arun")));
}
#Test
public void deletePerson_Success() throws Exception {
Mockito.when(personRepository.findById(person1.getId())).thenReturn(Optional.of(person1));
mockMvc.perform(MockMvcRequestBuilders.delete("/delete/1")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
}
}

Related

How to correctly stop and start a localstack instance

I am using Localstack to write integration tests. One of the scenarios I want to test is when the AWS service throws error. My test looks like
void saveEventsAsync_snsError() throws Exception{
localSns.stop();
mvc.perform( MockMvcRequestBuilders
.post("/events-async")
.content(validRequest())
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isInternalServerError());
}
However doing do fails one another test with HttpConnection refused.. error. Presumably the container didn't start by the time the test ran.
What are my options here ? Looping with localSns.isRunning() doesn;t seem to help
Here's full test clas for reference
package ....
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Profile;
import org.springframework.http.MediaType;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.testcontainers.containers.localstack.LocalStackContainer;
import org.testcontainers.containers.wait.strategy.DockerHealthcheckWaitStrategy;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.CreateTopicRequest;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.testcontainers.containers.localstack.LocalStackContainer.Service.SNS;
#SpringBootTest
#AutoConfigureMockMvc
#ActiveProfiles("test")
#Testcontainers
#TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class EventReportingControllerTest {
#Autowired
MockMvc mvc;
#Container
private static final LocalStackContainer localSns =
new LocalStackContainer(DockerImageName.parse("localstack/localstack:0.11.3"))
.withServices(SNS);
private static SnsClient snsClient;
private static String topicArn ;
#BeforeAll
static void beforeAll() {
localSns.start();
snsClient = SnsClient.builder()
.endpointOverride(localSns.getEndpointOverride(SNS))
.credentialsProvider(
StaticCredentialsProvider.create(
AwsBasicCredentials.create(localSns.getAccessKey(), localSns.getSecretKey())
)
)
.region(Region.of(localSns.getRegion()))
.build();
topicArn = snsClient.createTopic(CreateTopicRequest.builder().name("testTopic").build()).topicArn();
}
#DynamicPropertySource
public static void overrideProps(DynamicPropertyRegistry registry){
registry.add("events.sns.topic.arn", () -> snsClient.createTopic(CreateTopicRequest.builder().name("testTopic").build()).topicArn());
}
#TestConfiguration
public static class SnsClientConfig {
#Bean
#Profile("test")
public SnsClient amazonSNSClient() {
return snsClient;
}
}
#Test
void saveEventsAsync_success() throws Exception{
mvc.perform( MockMvcRequestBuilders
.post("/events-async")
.content(validRequest())
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isAccepted()
);
}
#Test
void saveEventsAsync_invalidRequest() throws Exception{
mvc.perform( MockMvcRequestBuilders
.post("/events-async")
.content(invalidRequest())
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isBadRequest());
}
#Test
void saveEventsAsync_snsError() throws Exception{
localSns.stop();
mvc.perform( MockMvcRequestBuilders
.post("/events-async")
.content(validRequest())
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON))
.andExpect(status().isInternalServerError());
}
}
When using #Testconainers and #Container for your setup, Testcontainers will manage the lifecycle of the container for you.
Hence, you currently have a mix of self-manging and "managed by Testcontainers".
If you want to take over the lifecycle handling, remove the two annotations and start/stop the container according to your preference.
PS: If you're using a recent Spring Cloud AWS version, overriding the AWS SDK client is way simpler now.

Junit test cases for Rest API using Junit and Mockito

Junit test cases for API's
I'm new to Junit and Mockito, trying to write unit test cases for my controller class to test my APIs.
Here is the controller class
package com.mylearnings.controller;
import com.mylearnings.modal.Product;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
#RestController
public class ProductController {
private HashMap<String, Product> productCatalog = new HashMap<>();
#PostMapping("/product")
public ResponseEntity addProduct(#RequestBody Product product) {
productCatalog.put(product.getId(), product);
return new ResponseEntity("product added successfully", HttpStatus.CREATED);
}
#GetMapping("/product/{id}")
public ResponseEntity getProductDetails(#PathVariable String id) {
return ResponseEntity.ok(productCatalog.get(id));
}
#GetMapping("/product")
public List<Product> getProductList() {
return new ArrayList<>(productCatalog.values());
}
#PutMapping("/product")
public String updateProduct(#RequestBody Product product) {
productCatalog.put(product.getId(), product);
return "product updated successfully";
}
#DeleteMapping("/product/{id}")
public String deleteProduct(#PathVariable String id) {
productCatalog.remove(id);
return "product deleted successfully";
}
}
I have tried the following
Added #ExtendWith(MockitoExtension.class) and tried but still it's failing
package com.mylearnings.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mylearnings.modal.Product;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.web.context.WebApplicationContext;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
#SpringBootTest
#AutoConfigureMockMvc
public class ProductControllerTest {
#Autowired
private MockMvc mockMvc;
#Autowired
private WebApplicationContext webApplicationContext;
#Mock
private Map<String, Product> productCatalog;
#InjectMocks
private ProductController productController;
#Test
public void testAddProduct() throws Exception {
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.post("/product").contentType(MediaType.APPLICATION_JSON).content(new ObjectMapper().writeValueAsString(new Product("MS116", "Dell MS116", "Dell MS116 Usb wired optical mouse", "", 229d)))).andReturn();
assertEquals(201, mvcResult.getResponse().getStatus());
}
#Test
public void testGetProductDetails() throws Exception {
Product product = new Product("MS116", "Dell MS116", "Dell MS116 Usb wired optical mouse", "", 229d);
when(productCatalog.get("MS116")).thenReturn(product);
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get("/product/{id}", "MS116").accept(MediaType.APPLICATION_JSON)).andReturn();
assertEquals(200, mvcResult.getResponse().getStatus());
Product result = new ObjectMapper().readValue(mvcResult.getResponse().getContentAsString(), Product.class);
assertEquals(product, result);
}
}
the test case testGetProductDetails() is failing, I'm not sure whether it is because of map?
In order to be able to inject mocks into Application context using (#Mock and #InjectMocks) and make it available for you MockMvc, you can try to init MockMvc in the standalone mode with the only ProductController instance enabled (the one that you have just mocked).
Example:
package com.mylearnings.controller;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
import com.mylearnings.controller.Product;
import com.mylearnings.controller.ProductController;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import org.junit.jupiter.api.BeforeEach;
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.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
#ExtendWith(MockitoExtension.class)
public class ProductControllerTest {
private MockMvc mockMvc;
#Mock
private HashMap<String, Product> productCatalog;
#InjectMocks
private ProductController productController;
#BeforeEach
public void setup() {
mockMvc = MockMvcBuilders.standaloneSetup(productController)
.build();
}
#Test
public void testAddProduct() throws Exception {
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.post("/product").contentType(MediaType.APPLICATION_JSON)
.content(new ObjectMapper().writeValueAsString(new Product("MS116", "Dell MS116", "Dell MS116 Usb wired optical mouse", "", 229d))))
.andReturn();
assertEquals(201, mvcResult.getResponse().getStatus());
}
#Test
public void testGetProductDetails() throws Exception {
Product product = new Product("MS116", "Dell MS116", "Dell MS116 Usb wired optical mouse", "", 229d);
when(productCatalog.get("MS116")).thenReturn(product);
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get("/product/{id}", "MS116").accept(MediaType.APPLICATION_JSON)).andReturn();
assertEquals(200, mvcResult.getResponse().getStatus());
Product result = new ObjectMapper().readValue(mvcResult.getResponse().getContentAsString(), Product.class);
assertEquals(product, result);
}
}

Getting 500 error while testing webflux code with wiremock

I have spring webflux app with user controller class with end point "/user and user service class.The user service class making call to external api. I am trying to test the service class using wiremock and junit 5 to mock out external api.. However I am getting below error ->
021-07-30 18:22:52.511 ERROR 16974 --- [o-auto-1-exec-2] o.a.c.c.C.[.[.[/].[dispatcherServlet] : Servlet.service() for servlet [dispatcherServlet] threw exception
java.net.ConnectException: Connection refused
Code is uploaded at path : https://github.com/neeleshsethi/wiremockdemp/tree/master
It seems it cannot find controller as adding a print statement in controller is not printing anything. Below is the code ->
#Service
public class UserService {
#Autowired
WebClient webClient;
public Mono<User> createuser(User user) {
return webClient.post()
.uri("/usercreate")
.contentType(MediaType.APPLICATION_JSON)
.accept(MediaType.APPLICATION_JSON)
.body(BodyInserters.fromValue(user))
.retrieve()
.bodyToMono(User.class);
}
}
WireMock Inti class:
package com.example.wiremockdemo;
import com.github.tomakehurst.wiremock.WireMockServer;
import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ContextClosedEvent;
import java.util.Map;
public class WireMockInit implements ApplicationContextInitializer<ConfigurableApplicationContext> {
#Override
public void initialize(ConfigurableApplicationContext applicationContext) {
WireMockServer wireMockServer = new WireMockServer(new WireMockConfiguration().dynamicPort());
wireMockServer.start();
applicationContext.addApplicationListener( applicationEvent ->
{
if(applicationEvent instanceof ContextClosedEvent)
{
wireMockServer.stop();
}
}
);
applicationContext.getBeanFactory().registerSingleton("wireMockServer", wireMockServer);
TestPropertyValues.of("externalBaseUrl",wireMockServer.baseUrl())
.applyTo(applicationContext);
}
}
test class:
package com.example.wiremockdemo;
import com.example.wiremockdemo.model.User;
import com.github.tomakehurst.wiremock.WireMockServer;
import com.github.tomakehurst.wiremock.client.WireMock;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.web.reactive.function.BodyInserters;
import reactor.core.publisher.Mono;
import java.awt.*;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
#SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
#ContextConfiguration(initializers = {WireMockInit.class})
class WiremockdemoApplicationTests {
#Autowired
WebTestClient webTestClient;
#Autowired
private WireMockServer wireMockServer;
#LocalServerPort
private Integer port;
#Test
void createUsertest() {
System.out.println("Creating stub");
wireMockServer.stubFor(
WireMock.post("/usercreate")
.willReturn(
aResponse()
.withHeader("Content-Type", MediaType.APPLICATION_JSON_VALUE)
.withBodyFile("response.json"))
);
byte[] temp = webTestClient.post()
.uri("http://localhost:" + port + "/user")
// .uri("/user")
.contentType(MediaType.APPLICATION_JSON)
//.accept(MediaType.APPLICATION_JSON)
.body(BodyInserters.fromValue(createUser()))
.exchange()
.expectBody()
.returnResult()
.getResponseBody();
String s = new String(temp);
System.out.println("Response :" +s);
}
public User createUser()
{
return User.builder()
.firstName("neel")
.age(32)
.id(1234)
.build();
}
}
Change this line to:
TestPropertyValues.of(Map.of("externalBaseUrl", wireMockServer.baseUrl()));
This is the correct way to set test properties.

Unable to Mock RestTemplate.exchange

As part of TDD i want to be able to test every portion of my SpringBoot rest application. However i am unable to mock external calls.
Application structure
1. Few rest endpoints which internally call external rest endpoints.
2. All calls to external endpoints are orchestrated through a local http client which utilizes RestTemplate as httpClient.
#RunWith(SpringRunner.class)
#SpringBootTest(webEnvironment = WebEnvironment.MOCK, classes = TestDrivenDevelopmentWithJavaApplication.class)
public class TestDrivenDevelopmentWithJavaApplicationTests {
#Autowired
private WebApplicationContext webApplicationContext;
private MockMvc mockMvc;
#MockBean
private RestTemplate client;
#Before
public void setup() throws Exception {
mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
Structure1Root category = new Structure1Root();
Category cat = new Category();
cat.setCategoryName("Test1");
cat.setDescription("Test");
category.setD(cat);
Mockito.when(client.exchange(
ArgumentMatchers.eq("https://services.odata.org/V2/Northwind/Northwind.svc/Products(1)?$format=json"),
ArgumentMatchers.eq(HttpMethod.GET), ArgumentMatchers.eq(null),
ArgumentMatchers.eq(Structure1Root.class)))
.thenReturn(new ResponseEntity<Structure1Root>(category, HttpStatus.OK));
}
#Test
public void testendpoint1() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/endpoint1?token=1").contentType(MediaType.APPLICATION_JSON))
.andExpect(content().string(org.hamcrest.Matchers.containsString("Test1")));
}
}
Even though i have setup the mock on client.exchange(RestTemplate.exchange), i see response returned by client.exchange is null and not the response specified in thenReturn
Controller Code
#RestController
#RequestMapping(path = Endpoint.base)
public class Endpoint {
public static final String base = "/api";
#Autowired
MyHttpClient<Structure2Root> client;
#Autowired
MyHttpClient<Structure1Root> Cclient;
#GetMapping(path = "/endpoint1")
public ResponseEntity<Structure2Root> callEndpt1(#RequestParam String token) {
Response<Structure2Root> resp = client
.execute("https://services.odata.org/V2/Northwind/Northwind.svc/Products(1)?$format=json", Structure2Root.class);
return new ResponseEntity<Structure2Root>(resp.getResponse(), HttpStatus.OK);
}
#GetMapping(path = "/endpoint2")
public ResponseEntity<Structure1Root> callEndpt2(#RequestParam String token) {
Response<Structure1Root> resp = Cclient.execute(
"https://services.odata.org/V2/Northwind/Northwind.svc/Categories(1)?$format=json", Structure1Root.class);
return new ResponseEntity<Structure1Root>(resp.getResponse(),HttpStatus.OK);
}
}
And finally, local http client code
#Service
public class MyHttpClient<O> {
#Autowired
RestTemplate client;
public MyHttpClient() {
// TODO Auto-generated constructor stub
}
public Response<O> execute(String url, Class<O> generic) {
ResponseEntity<O> resp = client.exchange(url, HttpMethod.GET, null, generic);
return new Response<O>(resp.getStatusCode(), resp.getBody());
}
}
this client.execute is what i intend to intercept in the first code block
However never seems to work and always returns a null.
The Git Repo
Regards,
Veera
You have used the wrong object while mocking. You should be using Structure2Root rather then Structure1Root
The correct test class is below which is working perfectly fine.
package com.demo.samples.tdd;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import com.demo.samples.tdd.responses.Product;
import com.demo.samples.tdd.responses.Structure2Root;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatchers;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.context.WebApplicationContext;
import com.demo.samples.tdd.responses.Category;
import com.demo.samples.tdd.responses.Structure1Root;
#RunWith(SpringRunner.class)
#SpringBootTest(webEnvironment = WebEnvironment.MOCK, classes = TestDrivenDevelopmentWithJavaApplication.class)
public class TestDrivenDevelopmentWithJavaApplicationTests {
#Autowired
private WebApplicationContext webApplicationContext;
private MockMvc mockMvc;
#MockBean
private RestTemplate client;
#Before
public void setup() throws Exception {
mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
// Structure1Root category = new Structure1Root();
// Category cat = new Category();
// cat.setCategoryName("Test1");
// cat.setDescription("Test");
// category.setD(cat);
//
// Mockito.when(client.exchange(
// ArgumentMatchers.eq("https://services.odata.org/V2/Northwind/Northwind.svc/Products(1)?$format=json"),
// ArgumentMatchers.eq(HttpMethod.GET), ArgumentMatchers.eq(null),
// ArgumentMatchers.eq(Structure1Root.class)))
// .thenReturn(new ResponseEntity<Structure1Root>(category, HttpStatus.OK));
Structure2Root category2 = new Structure2Root();
Product product = new Product();
product.setProductName("Test1");
product.setUnitPrice("1");
category2.setD(product);
Mockito.when(client.exchange(
ArgumentMatchers.eq("https://services.odata.org/V2/Northwind/Northwind.svc/Products(1)?$format=json"),
ArgumentMatchers.eq(HttpMethod.GET), ArgumentMatchers.eq(null),
ArgumentMatchers.eq(Structure2Root.class)))
.thenReturn(new ResponseEntity<Structure2Root>(category2, HttpStatus.OK));
}
#Test
public void testendpoint1() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/endpoint1?token=1").contentType(MediaType.APPLICATION_JSON))
.andExpect(content().string(org.hamcrest.Matchers.containsString("Test1")));
}
}

Cannot find test class - Spring Boot

We have a spring boot application and have written test cases for the service class. The test case is running when I am running it as Right Click -> Run As -> JUnit Test. But when I am running it through maven, it is not found. My test class is as below:
package dk.tdc.fasapi.service;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import dk.tdc.fasapi.repository.implementation.jdbc.IncidentDetailsRepo;
import dk.tdc.fasapi.requestResponse.incidents.getdetails.IncidentDetails;
#RunWith(MockitoJUnitRunner.class)
public class TestIncidentDetailsService {
private Map<String, Object> fasoDetailsMap = null;
private List<Map<String, Object>> subStateMapList = null;
#Mock
private IncidentDetailsRepo incidentDetailsRepo;
#InjectMocks
private IncidentDetailsService incidentDetailsService;
#Before
public void beforeMethod() {
fasoDetailsMap = new HashMap<>();
fasoDetailsMap.put("FaultDescription", "Test Description");
fasoDetailsMap.put("UrgentCode", "01");
fasoDetailsMap.put("LID", "12345678");
fasoDetailsMap.put("CustomerName", "TDC");
fasoDetailsMap.put("CustomerPhone", "11223344");
fasoDetailsMap.put("ExtRefId", "1234");
fasoDetailsMap.put("SSID", "0001");
Map<String, Object> subStateMap = new HashMap<String, Object>();
subStateMap.put("X_CURRENT_STATUS", "Accepted");
subStateMapList = new ArrayList<Map<String,Object>>();
subStateMapList.add(subStateMap);
}
#Test
public void testExecuteOpenFaso() throws Exception {
Mockito.when(incidentDetailsRepo.getOpenFasoDetails(Mockito.anyString())).thenReturn(fasoDetailsMap);
Mockito.when(incidentDetailsRepo.getCurrentStatus(Mockito.anyString())).thenReturn(subStateMapList);
IncidentDetails incidentDetails = incidentDetailsService.execute("20181225-000001");
Assert.assertEquals(incidentDetails.getId(), "20181225-000001");
Assert.assertEquals(incidentDetails.getStatus(), "Open");
Assert.assertEquals(incidentDetails.getTitle(), "Test Description");
Assert.assertEquals(incidentDetails.getSeverity(), "01");
Assert.assertEquals(incidentDetails.getParameter().getType(), "LID");
Assert.assertEquals(incidentDetails.getParameter().getValue(), "12345678");
Assert.assertEquals(incidentDetails.getContact().getName(), "TDC");
Assert.assertEquals(incidentDetails.getContact().getNumber(), "11223344");
Assert.assertEquals(incidentDetails.getReferences().getTicket(), "1234");
Assert.assertEquals(incidentDetails.getReferences().getSsid(), "0001");
Assert.assertEquals(incidentDetails.getReferences().getContractor(), "ENIIG180619");
Assert.assertEquals(incidentDetails.getSubState(), "Accepted");
}
#Test
public void testExecuteClosedFaso() throws Exception {
Mockito.when(incidentDetailsRepo.getOpenFasoDetails(Mockito.anyString())).thenReturn(null);
Mockito.when(incidentDetailsRepo.getClosedFasoDetails(Mockito.anyString())).thenReturn(fasoDetailsMap);
Mockito.when(incidentDetailsRepo.getCurrentStatus(Mockito.anyString())).thenReturn(subStateMapList);
IncidentDetails incidentDetails = incidentDetailsService.execute("20181225-000001");
Assert.assertEquals(incidentDetails.getId(), "20181225-000001");
Assert.assertEquals(incidentDetails.getStatus(), "Closed");
Assert.assertEquals(incidentDetails.getTitle(), "Test Description");
Assert.assertEquals(incidentDetails.getSeverity(), "01");
Assert.assertEquals(incidentDetails.getParameter().getType(), "LID");
Assert.assertEquals(incidentDetails.getParameter().getValue(), "12345678");
Assert.assertEquals(incidentDetails.getContact().getName(), "TDC");
Assert.assertEquals(incidentDetails.getContact().getNumber(), "11223344");
Assert.assertEquals(incidentDetails.getReferences().getTicket(), "1234");
Assert.assertEquals(incidentDetails.getReferences().getSsid(), "0001");
Assert.assertEquals(incidentDetails.getReferences().getContractor(), "ENIIG180619");
Assert.assertEquals(incidentDetails.getSubState(), "Accepted");
}
#After
public void afterMethod() {
fasoDetailsMap = null;
}
}
Can anyone please suggest whether I will have to add any more annotations on my test class to make it visible?

Resources