Issue
I am trying to test a Service class using JUnit and Mockito. Not sure how to include the HTTP GET Request URI in the test method. I am trying to create and build the request using HttpClientBuilder, but somehow the imports are not found even after I include the Gradle dependency. I also have Header parameters in the request.
My Java class is as follows:
@GET
@Path("/home")
public Response getAllEmployees(@HeaderParam("user") String user, @HeaderParam("password") String password) {
List<Info> listOfInfo = new ArrayList<>();
LoginUser loginUser = checkLoginValidation();
if(loginUser != null){
List<Employees> list = employeeManager.fetchAllEmployees();
if(list == null || list.isEmpty()){
return Response.status(Status.NO_CONTENT).build();
}
listOfInfo = getEmployees(list);
log.info(listOfInfo);
return Response.ok(listOfInfo, MediaType.APPLICATION_JSON_TYPE).build();
}
return Response.status(Status.BAD_REQUEST).build();
}
That's all I have written in the test class below:
@RunWith(MockitoJUnitRunner.class)
public class FinderServiceTest {
@InjectMocks
private FinderService finderService;
@Test
public void testMethod() {
HttpGet request = new HttpGet("http://localhost:8080/home");
//Don't know how to proceed further
}
}
Any help would be much appreciated!
Solution
The way your question is phrased I'm concerned that you're mixing unit and integration level testing.
At a Unit level you want to work to assert that when controlled parameters are passed to a method that you can predictably assert what that method will do and return to the client. It's an isolate test that separates that method from the environment which it will be executing in, and focuses on ensuring predictable behavior from a small section of your code.
At an integration level you would then treat the class "as it exists at runtime". You would put it in a container, start the bean or service, and make calls against it to ensure that when it's running the behavior is equally predictable and outside clients will get the results you're expecting from the public through your full running stack (or controlled stack sub-set). Integration testing is checking that the application is operating, collectively, as you intend.
With the test you've proposed, I feel like you're trying to perform a Unit test of the method. I would suggest not worrying about how the arguments will be derived from the Header at runtime and just call the method directly.
Below is a stub of how I beleive I would attempt to unit-test the ServiceFinder.getAllLockers(String, String) method
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.internal.util.reflection.Whitebox;
public class FinderServiceTest {
// This is created new between each test.
private ServiceFinder serviceFinder = new ServiceFinder();
/* ***************************************/
/* PARAMETER TESTS
/* ***************************************/
/*
* What should happen in these cases? - Is it an Exception? - Should the method return Status.BAD_REQUEST?
*
* org.junit.Assert can be used to compare the response Object with the desired outcome OR
* org.junit.rules.ExpectedException can be used to verify specific exceptions are thrown
*/
@Test
public void testGetAllLockersNullUserParam() {
Response response = serviceFinder.getAllLockers(null, "password");
// Assert the right thing happened.
}
@Test
public void testGetAllLockersEmptyUserParam() {
Response response = serviceFinder.getAllLockers("", "password");
// Assert the right thing happened.
}
@Test
public void testGetAllLockersNullPasswordParam() {
Response response = serviceFinder.getAllLockers("user", null);
// Assert the right thing happened.
}
@Test
public void testGetAllLockersEmptyPasswordParam() {
Response response = serviceFinder.getAllLockers("user", "");
// Assert the right thing happened.
}
/* ***************************************/
/* BRANCH TESTS (SHORT PATHS)
/* ***************************************/
@Test
public void testGetAllLockersNullValidatedUser() {
// For ease of use in my case I'm going to pretend that checkLoginValidation
// just calls a delegate interface, which I'm calling LoginValidator, with the same API.
// Which I will mock and set the expected return...
LoginValidator mockLoginValidator = Mockito.mock(LoginValidator.class);
Mockito.when(mockLoginValidator.checkLoginValidation()).thenReturn(null);
//Using PowerMock, I'm going to set the LoginValidator field inside of my service finder.
//I'm assuming that LoginValidator field in the ServiceFinder is named "loginValidator"
Whitebox.setInternalState(serviceFinder, "loginValidator", mockLoginValidator);
//Now that my class is set up to give me the null Validated User, I'll make the call to the test instance
Response response = serviceFinder.getAllLockers("validUser", "validPassword");
//From the implementation posted, I know that when the user validates as null I should get back something with a Status.BAD_REQUEST state.
assertEquals("When the logged in user is null BAD_REQUEST should be returned", Status.BAD_REQUEST, response.getStatus);
}
@Test
public void testGetAllLockersNullEmployeeList() {
//FIXME: Configure user validation to return LoginUser Object.
//FIXME: Configure test reference state to return a null employee list when employeeManager.fetchAllEmployees() is called
Response response = serviceFinder.getAllLockers("validUser", "validPassword");
assertEquals("When the employee list is null NO_CONTENT should be returned", Status.NO_CONTENT, response.getStatus);
}
@Test
public void testGetAllLockersEmptyEmployeeList() {
//FIXME: Configure user validation to return LoginUser Object.
// FIXME: Configure test reference state to return an empty employee list when employeeManager.fetchAllEmployees() is called
Response response = serviceFinder.getAllLockers("validUser", "validPassword");
assertEquals("When the employee list is null NO_CONTENT should be returned", Status.NO_CONTENT, response.getStatus);
}
/* ***************************************/
/* HAPPY PATH TEST
/* ***************************************/
public void testgetAllLockers() {
//FIXME: Configure user validation to return LoginUser Object.
// FIXME: Configure test reference state to return a correctly-populated employee list when employeeManager.fetchAllEmployees() is called
Response response = serviceFinder.getAllLockers("validUser", "validPassword");
assertEquals("When the employee list is null NO_CONTENT should be returned", Status.OK, response.getStatus);
//FIXME get JSON from response reference
//FIXME Check that JSON holds all of the expected employee list data
}
}
At a unit level that ensures the method is doing what we expect repeatedly.
The Integration Test is another beast altogether in my mind. You'll need to get your code running on a server and set up a tool that can make calls against the running URL. That configuration is not something I'm overly familiar with, so I am not of much help in that regard. I do know there are a large number of ways to do this, and a number of programs and utilities to assist. A few google searches on integration testing rest api's and I'm sure you'll have a plethora of options. I suggest you look for a solution that closely resembles the environment you intend to have this running on in the end.
What I can offer is to note that it is during integration testing you'll want to use something like HttpClientBuilder, or a tool like JMeter or Postman to fire requests for information to the server, and then read and validate the response is what you expect. You may want to use some of the data that we tried in the unit test to ensure that the running system doesn't change the intended results.
Best of Luck!
Answered By - Jeremiah
Answer Checked By - Gilberto Lyons (JavaFixing Admin)
