Summary Table
Categories |
Total Count |
PII |
0 |
URL |
0 |
DNS |
0 |
EKL |
0 |
IP |
0 |
PORT |
0 |
VsID |
0 |
CF |
0 |
AI |
0 |
VPD |
0 |
PL |
0 |
Other |
0 |
File Content
package gov.va.oneconsult.seoc.api.controller;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.context.embedded.LocalServerPort;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
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 gov.va.oneconsult.seoc.api.Application;
import gov.va.oneconsult.seoc.api.json.CreateUserRequest;
import gov.va.oneconsult.seoc.api.model.User;
import gov.va.oneconsult.seoc.api.util.Constants;
import gov.va.oneconsult.seoc.api.util.DeserializeTest;
import gov.va.oneconsult.seoc.api.util.EncodeLoggerFactory;
import gov.va.oneconsult.seoc.api.util.TestUtil;
/**
* Integration Test Cases for User Management end points
*
* @author AbleVets
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserControllerIntTest
{
@LocalServerPort
private int port;
private TestRestTemplate restTemplate = new TestRestTemplate();
private HttpHeaders headers = new HttpHeaders();
public static final Logger logger = EncodeLoggerFactory.getLogger(UserControllerIntTest.class);
public static final DeserializeTest deserialize = new DeserializeTest();
public static final String ROOT = "/v1/user/";
public static final String GET_ALL = "all";
public static final String SAVE = "save";
public static final String DELETE = "delete/";
public static final String MAINTENANCE = "maint/";
private int initialSize = 0;
public static final String vaUserId = "System";
@Before
public void setup()
{
setHeaders();
/*============================Get All Users==================================*/
HttpEntity<String> entity = new HttpEntity<String>(null, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
Set<User> users = deserialize.getUsersFromResponse(response.getBody());
if(users!=null) {
initialSize = users.size();
}
assertEquals(HttpStatus.OK, response.getStatusCode());
}
@After
public void tearDown()
{
}
/**
* Description: add new User - get all to see new user is added
*/
@Test
public void testSaveNew()
{
String role = "Role";
String userName = "UserName";
String vaNetworkId = "NetworkId";
String domain = "Domain";
/*============================Create New User==================================*/
CreateUserRequest userRequset = CreateUserRequest.Builder.create()
.withDomain(domain)
.withRole(role)
.withUserName(userName)
.withVaNetworkId(vaNetworkId)
.build();
String requestJson = SeocObjectGenerator.asJsonString(userRequset);
HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
String actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
String expectedStatus = Constants.CREATED;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
//Check if new User is in the get all Users list
/*============================Get All Users==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
Set<User> users = deserialize.getUsersFromResponse(response.getBody());
int currentSize = users!=null?users.size():0;
assertThat(currentSize).isEqualTo(initialSize+1);
//Found saved user
users.forEach(user -> {
if(user.getUserName().equalsIgnoreCase(userName)) {
user.getDomain().equalsIgnoreCase(domain);
user.getVaNetworkId().equalsIgnoreCase(vaNetworkId);
user.getRole().equalsIgnoreCase(role);
}
});
}
/**
* Description: Add new user - get all users check to find new user - update the user - get all users to see the data is updated
*/
@Test
public void testUpdate()
{
String role = "Role1";
String userName = "UserName1";
String vaNetworkId = "NetworkId1";
String domain = "Domain1";
User userBefore = null;
User userAfterUpdate = null;
/*============================Create New User==================================*/
CreateUserRequest userRequset = CreateUserRequest.Builder.create()
.withDomain(domain)
.withRole(role)
.withUserName(userName)
.withVaNetworkId(vaNetworkId)
.build();
String requestJson = SeocObjectGenerator.asJsonString(userRequset);
HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
String actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
String expectedStatus = Constants.CREATED;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
//Check if new User is in the get all Users list
/*============================Get All Users After create==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
Set<User> users = deserialize.getUsersFromResponse(response.getBody());
Set<User> matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
assertThat(matchedUsers).isNotEmpty();
assertThat(matchedUsers.size()).isEqualTo(1);
for(User user : matchedUsers) {
userBefore = user;
}
/*============================Update User==================================*/
String newDomain = "NewDomain";
String newUserName = "NewRole";
String newRole = "newRole";
userRequset = CreateUserRequest.Builder.create()
.withDomain(newDomain)
.withRole(newRole)
.withUserName(newUserName)
.withVaNetworkId(vaNetworkId)
.withPrevNetworkId(vaNetworkId)
.build();
requestJson = SeocObjectGenerator.asJsonString(userRequset);
entity = new HttpEntity<String>(requestJson, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
expectedStatus = Constants.UPDATED;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
//Check if updated User is in the get all Users list and check if the values are updated
/*============================Get All Users after update==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
users = deserialize.getUsersFromResponse(response.getBody());
matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
assertThat(matchedUsers).isNotEmpty();
assertThat(matchedUsers.size()).isEqualTo(1);
for(User user : matchedUsers) {
userAfterUpdate = user;
}
//same user has been updated assert that
//networkID was not changed but other details are changed
assertThat(userBefore.getVaNetworkId()).isEqualTo(userAfterUpdate.getVaNetworkId());
assertThat(userBefore.getDomain()).isNotEqualTo(userAfterUpdate.getDomain());
assertThat(userBefore.getUserName()).isNotEqualTo(userAfterUpdate.getUserName());
assertThat(userBefore.getRole()).isNotEqualTo(userAfterUpdate.getRole());
}
/**
* Description: add new user - get all to find new user - delete user - get all to see user is not in the list
*/
@Test
public void testDelete()
{
String role = "Role2";
String userName = "UserName2";
String vaNetworkId = "NetworkId2";
String domain = "Domain2";
/*============================Create New User==================================*/
CreateUserRequest userRequset = CreateUserRequest.Builder.create()
.withDomain(domain)
.withRole(role)
.withUserName(userName)
.withVaNetworkId(vaNetworkId)
.build();
String requestJson = SeocObjectGenerator.asJsonString(userRequset);
HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
String actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
String expectedStatus = Constants.CREATED;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
//Check if new User is in the get all Users list
/*============================Get All Users After create==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
Set<User> users = deserialize.getUsersFromResponse(response.getBody());
Set<User> matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
assertThat(matchedUsers).isNotEmpty();
assertThat(matchedUsers.size()).isEqualTo(1);
/*============================Delete User==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+ DELETE + vaNetworkId),
HttpMethod.DELETE, entity, String.class);
actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
expectedStatus = Constants.SUCCESS;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
//Check if updated User is in the get all Users list and check if the values are updated
/*============================Get All Users after update==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
users = deserialize.getUsersFromResponse(response.getBody());
matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
//No user found with matching networkID. User deleted
assertThat(matchedUsers).isEmpty();
}
/**
* Description: try to delete a user that never exists
*/
@Test
public void testDeleteNonExistingUser()
{
String vaNetworkId = "NetworkId";
/*============================trying to Delete a User which never existed ==================================*/
HttpEntity<String> entity = new HttpEntity<String>(null, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ DELETE + vaNetworkId),
HttpMethod.DELETE, entity, String.class);
String actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
String expectedStatus = Constants.FAILURE;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
}
/**
* Description: networkId passed during delete is empty
*/
@Test
public void testDeleteUserNetworkIdEmpty()
{
String vaNetworkId = " ";
/*============================trying to Delete a User which never existed ==================================*/
HttpEntity<String> entity = new HttpEntity<String>(null, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ DELETE + vaNetworkId),
HttpMethod.DELETE, entity, String.class);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
}
/**
* Description: add new user - get all to find new user - delete user - get all to see user not in the list - add user with same username and networkId
* System should not stop from adding new user with same details as the deleted user.
*/
@Test
public void testAddUserWithDetailsOfDeletedUser()
{
String role = "Role3";
String userName = "UserName3";
String vaNetworkId = "NetworkId3";
String domain = "Domain3";
User userBefore = null;
User userWithSameInfo = null;
/*============================Create New User==================================*/
CreateUserRequest userRequset = CreateUserRequest.Builder.create()
.withDomain(domain)
.withRole(role)
.withUserName(userName)
.withVaNetworkId(vaNetworkId)
.build();
String requestJson = SeocObjectGenerator.asJsonString(userRequset);
HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
String actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
String expectedStatus = Constants.CREATED;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
//Check if new User is in the get all Users list
/*============================Get All Users After create==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
Set<User> users = deserialize.getUsersFromResponse(response.getBody());
Set<User> matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
assertThat(matchedUsers).isNotEmpty();
assertThat(matchedUsers.size()).isEqualTo(1);
for(User user : matchedUsers) {
userBefore = user;
}
//assert that all fields have values as expected
assertThat(userBefore.getVaNetworkId()).isEqualTo(vaNetworkId);
assertThat(userBefore.getDomain()).isEqualTo(domain);
assertThat(userBefore.getUserName()).isEqualTo(userName);
assertThat(userBefore.getRole()).isEqualTo(role);
/*============================Delete User==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+ DELETE + vaNetworkId),
HttpMethod.DELETE, entity, String.class);
actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
expectedStatus = Constants.SUCCESS;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
//Check if the deleted user no longer exists in the get all user list
/*============================Get All Users after delete==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
users = deserialize.getUsersFromResponse(response.getBody());
matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
//No user found with matching networkID. User deleted
assertThat(matchedUsers).isEmpty();
/*============================Create New User with same details as deleted user==================================*/
userRequset = CreateUserRequest.Builder.create()
.withDomain(domain)
.withRole(role)
.withUserName(userName)
.withVaNetworkId(vaNetworkId)
.build();
requestJson = SeocObjectGenerator.asJsonString(userRequset);
entity = new HttpEntity<String>(requestJson, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
expectedStatus = Constants.CREATED;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
//Check if new User is in the get all Users list
/*============================Get All Users After create==================================*/
entity = new HttpEntity<String>(null, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
users = deserialize.getUsersFromResponse(response.getBody());
matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
assertThat(matchedUsers).isNotEmpty();
assertThat(matchedUsers.size()).isEqualTo(1);
for(User user : matchedUsers) {
userWithSameInfo = user;
}
//assert that all fields have same values
assertThat(userWithSameInfo.getVaNetworkId()).isEqualTo(vaNetworkId);
assertThat(userWithSameInfo.getDomain()).isEqualTo(domain);
assertThat(userWithSameInfo.getUserName()).isEqualTo(userName);
assertThat(userWithSameInfo.getRole()).isEqualTo(role);
}
/**
* Description: Add new user - get all users check to find new user - update the user - user to be updated is not found
*/
@Test
public void testUpdate_UserNotFound()
{
String vaNetworkId = "NetworkId4";
//Check if new User is in the get all Users list
/*============================Get All Users After create==================================*/
HttpEntity<String> entity = new HttpEntity<String>(null, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+GET_ALL),
HttpMethod.GET, entity, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
Set<User> users = deserialize.getUsersFromResponse(response.getBody());
Set<User> matchedUsers = users.stream()
.filter(u -> u.getVaNetworkId().equalsIgnoreCase(vaNetworkId))
.collect(Collectors.toSet());
assertThat(matchedUsers).isEmpty();
/*============================Update User==================================*/
String newDomain = "NewDomain";
String newUserName = "NewRole";
String newRole = "newRole";
CreateUserRequest userRequset = CreateUserRequest.Builder.create()
.withDomain(newDomain)
.withRole(newRole)
.withUserName(newUserName)
.withVaNetworkId(vaNetworkId)
.withPrevNetworkId(vaNetworkId)
.build();
String requestJson = SeocObjectGenerator.asJsonString(userRequset);
entity = new HttpEntity<String>(requestJson, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+ SAVE),
HttpMethod.PUT, entity, String.class);
String actualStatus = deserialize.genericResponse(response.getBody()).getStatus();
String expectedStatus = Constants.FAILURE;
assertThat(actualStatus).isEqualTo(expectedStatus);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
}
/**
* Description:Test read maintenanceMode
*/
@Test
public void testMaintenanceMode()
{
String user = null;
//Setting maintenance mode ON
String requestJson = "true";
HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.exchange(createURLWithPort(ROOT+ MAINTENANCE),
HttpMethod.PUT, entity, String.class);
//Assert that after setting the maintenance mode response is the vaUserId who requested to set maintenanace
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(deserialize.genericResponse(response.getBody()).getInMaintenanceBy()).contains(vaUserId);
//Get Maintenance mode after ON
response = restTemplate.exchange(
createURLWithPort(ROOT + MAINTENANCE), HttpMethod.GET, entity, String.class);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(deserialize.genericResponse(response.getBody()).getInMaintenanceBy()).contains(vaUserId);
//Setting maintenance mode OFF
requestJson = "false";
entity = new HttpEntity<String>(requestJson, headers);
response = restTemplate.exchange(createURLWithPort(ROOT+ MAINTENANCE),
HttpMethod.PUT, entity, String.class);
//Assert that after unsetting the maintenance mode response is blank
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
user = "";
assertThat(deserialize.genericResponse(response.getBody()).getInMaintenanceBy()).contains(user);
//Get Maintenance mode after OFF
response = restTemplate.exchange(
createURLWithPort(ROOT + MAINTENANCE), HttpMethod.GET, entity, String.class);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
user = "";
assertThat(deserialize.genericResponse(response.getBody()).getInMaintenanceBy()).contains(user);
}
/**
*
* Description: Set the headers
*/
private void setHeaders() {
headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
headers.set(Constants.USERID, vaUserId);
headers.set(Constants.CLIENT_KEY, TestUtil.CLIENT_KEY);
}
/**
* Description: Test url
*
* @param uri
* @return returns test url
*/
private String createURLWithPort(String uri)
{
return "http://localhost:" + port + uri;
}
}