package gov.samhsa.consent2share.web.controller;
import static org.hamcrest.Matchers.equalTo;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.model;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.view;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;
import gov.samhsa.consent2share.common.AuthenticatedUser;
import gov.samhsa.consent2share.common.UserContext;
import gov.samhsa.consent2share.infrastructure.PixService;
import gov.samhsa.consent2share.service.account.MrnService;
import gov.samhsa.consent2share.service.dto.LookupDto;
import gov.samhsa.consent2share.service.dto.PatientProfileDto;
import gov.samhsa.consent2share.service.dto.SystemNotificationDto;
import gov.samhsa.consent2share.service.notification.NotificationService;
import gov.samhsa.consent2share.service.patient.PatientService;
import gov.samhsa.consent2share.service.reference.AdministrativeGenderCodeService;
import gov.samhsa.consent2share.service.reference.LanguageCodeService;
import gov.samhsa.consent2share.service.reference.MaritalStatusCodeService;
import gov.samhsa.consent2share.service.reference.RaceCodeService;
import gov.samhsa.consent2share.service.reference.ReligiousAffiliationCodeService;
import gov.samhsa.consent2share.service.reference.StateCodeService;
import gov.samhsa.consent2share.service.systemnotification.SystemNotificationService;
import gov.samhsa.consent2share.service.validator.FieldValidator;
import gov.samhsa.consent2share.web.controller.PatientController;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentMatcher;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
@RunWith(MockitoJUnitRunner.class)
public class PatientControllerTest {
@InjectMocks
private PatientController sut = new PatientController();
@Mock
PatientService patientService;
@Mock
SystemNotificationService systemNotificationService;
@Mock
AdministrativeGenderCodeService administrativeGenderCodeService;
@Mock
LanguageCodeService languageCodeService;
@Mock
MaritalStatusCodeService maritalStatusCodeService;
@Mock
RaceCodeService raceCodeService;
@Mock
ReligiousAffiliationCodeService religiousAffiliationCodeService;
@Mock
StateCodeService stateCodeService;
@Mock
NotificationService notificationService;
@Mock
UserContext userContext;
@Mock
PixService pixService;
@Mock
MrnService mrnService;
@Mock
private FieldValidator fieldValidator;
private MockMvc mockMvc;
final static String VALID_FIRST_NAME = "Tom";
final static String VALID_LAST_NAME = "Lee";
final static String VALID_BIRTHDAY = "1/1/1950";
final static String VALID_EMAIL = "test@test.com";
final static String VALID_GENDER_CODE = "M";
final static String VALID_MRN = "PUI100000000001";
final static String VALID_EID = "1c5c59f0-5788-11e3-84b3-00155d3a2124";
final static String GENDER_FIELD = "administrativeGenderCode";
@Before
public void setUp() {
mockMvc = standaloneSetup(this.sut).build();
}
@Test
public void testProfile_When_HttpGet() throws Exception {
final String username = "username";
final AuthenticatedUser currentUser = mock(AuthenticatedUser.class);
when(currentUser.getUsername()).thenReturn(username);
when(userContext.getCurrentUser()).thenReturn(currentUser);
final PatientProfileDto patientProfile = new PatientProfileDto();
when(patientService.findPatientProfileByUsername(username)).thenReturn(
patientProfile);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(get("/patients/profile.html"))
.andExpect(status().isOk())
.andExpect(model().attributeExists("patientProfileDto"))
.andExpect(
model().attribute("patientProfileDto",
equalTo(patientProfile)))
.andExpect(
model().attribute("currentUser", equalTo(currentUser)))
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasNoErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Empty_Param_First_Name()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html").param("firstName", " ")
.param("lastName", VALID_LAST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testHome_when_authority_is_ROLE_USER() throws Exception {
final String username = "username";
final AuthenticatedUser currentUser = mock(AuthenticatedUser.class);
final PatientProfileDto patientProfileDto = mock(PatientProfileDto.class);
List<SystemNotificationDto> systemNotificationDtos = mock(List.class);
when(currentUser.getUsername()).thenReturn(username);
when(userContext.getCurrentUser()).thenReturn(currentUser);
when(patientService.findPatientProfileByUsername(anyString()))
.thenReturn(patientProfileDto);
when(
systemNotificationService
.findAllSystemNotificationDtosByPatient(anyLong()))
.thenReturn(systemNotificationDtos);
mockMvc.perform(get("/patients/home.html"))
.andExpect(view().name("views/patients/home"))
.andExpect(
model().attribute("systemNotificationDtos",
equalTo(systemNotificationDtos)))
.andExpect(
model().attribute("currentUser", equalTo(currentUser)));
}
@Test
public void testProfile_When_HttpPost_With_Invalide_Length_Param_First_Name()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html").param("firstName", "1")
.param("lastName", VALID_LAST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
mockMvc.perform(
post("/patients/profile.html")
.param("firstName", "1234567890123456789012345678901")
.param("lastName", VALID_LAST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Empty_Param_Last_Name()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html").param("lastName", " ")
.param("firstName", VALID_FIRST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Invalide_Length_Param_Last_Name()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html").param("lastName", "1")
.param("firstName", VALID_FIRST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
mockMvc.perform(
post("/patients/profile.html")
.param("lastName", "1234567890123456789012345678901")
.param("firstName", VALID_FIRST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Null_Param_Birth_Date()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html")
.param("firstName", VALID_FIRST_NAME)
.param("lastName", VALID_LAST_NAME)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(status().isOk())
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Invalid_Param_Birth_Date()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html").param("birthDate", "12/31/1899")
.param("firstName", " ")
.param("lastName", VALID_LAST_NAME)
.param("email", "ex@test.com")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Empty_Param_Email()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html")
.param("firstName", VALID_FIRST_NAME)
.param("lastName", VALID_LAST_NAME)
.param("birthDate", VALID_BIRTHDAY).param("email", " ")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Invalid_Param_Email()
throws Exception {
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
mockMvc.perform(
post("/patients/profile.html")
.param("firstName", VALID_FIRST_NAME)
.param("lastName", VALID_LAST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", "not-email-address")
.param(GENDER_FIELD, VALID_GENDER_CODE))
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
}
@Test
public void testProfile_When_HttpPost_With_Valid_Params() throws Exception {
final String username = "username";
final AuthenticatedUser currentUser = mock(AuthenticatedUser.class);
when(currentUser.getUsername()).thenReturn(username);
when(userContext.getCurrentUser()).thenReturn(currentUser);
fieldValidator = new FieldValidator();
ReflectionTestUtils.setField(sut, "fieldValidator", fieldValidator);
List<LookupDto> administrativeGenderCodes = mock(List.class);
when(administrativeGenderCodeService.findAllAdministrativeGenderCodes())
.thenReturn(administrativeGenderCodes);
List<LookupDto> maritalStatusCodes = mock(List.class);
when(maritalStatusCodeService.findAllMaritalStatusCodes()).thenReturn(
maritalStatusCodes);
List<LookupDto> religiousAffiliationCodes = mock(List.class);
when(religiousAffiliationCodeService.findAllReligiousAffiliationCodes())
.thenReturn(religiousAffiliationCodes);
List<LookupDto> raceCodes = mock(List.class);
when(raceCodeService.findAllRaceCodes()).thenReturn(raceCodes);
List<LookupDto> languageCodes = mock(List.class);
when(languageCodeService.findAllLanguageCodes()).thenReturn(
languageCodes);
List<LookupDto> stateCodes = mock(List.class);
when(stateCodeService.findAllStateCodes()).thenReturn(stateCodes);
when(mrnService.generateMrn()).thenReturn(VALID_MRN);
when(pixService.getEid(VALID_MRN)).thenReturn(VALID_EID);
mockMvc.perform(
post("/patients/profile.html")
.param("firstName", VALID_FIRST_NAME)
.param("lastName", VALID_LAST_NAME)
.param("birthDate", VALID_BIRTHDAY)
.param("email", VALID_EMAIL)
.param(GENDER_FIELD, VALID_GENDER_CODE)
.param("username", username)
.param("password", "password"))
.andExpect(
model().attribute("currentUser", equalTo(currentUser)))
.andExpect(
model().attribute("updatedMessage",
"Updated your profile successfully!"))
.andExpect(
model().attribute("administrativeGenderCodes",
equalTo(administrativeGenderCodes)))
.andExpect(model().attributeExists("maritalStatusCodes"))
.andExpect(
model().attribute("maritalStatusCodes",
equalTo(maritalStatusCodes)))
.andExpect(
model().attribute("religiousAffiliationCodes",
equalTo(religiousAffiliationCodes)))
.andExpect(model().attribute("raceCodes", equalTo(raceCodes)))
.andExpect(
model().attribute("languageCodes",
equalTo(languageCodes)))
.andExpect(model().attribute("stateCodes", equalTo(stateCodes)))
.andExpect(model().hasNoErrors())
.andExpect(view().name("views/patients/profile"))
.andDo(MockMvcResultHandlers.print());
ArgumentMatcher<PatientProfileDto> patientProfileArgumentMatcher = new ArgumentMatcher<PatientProfileDto>() {
@Override
public boolean matches(Object argument) {
PatientProfileDto patientProfileDto = (PatientProfileDto) argument;
if (patientProfileDto == null) {
return false;
}
if (patientProfileDto.getAddressCountryCode() == null
|| !patientProfileDto.getAddressCountryCode().equals(
"US")) {
return false;
}
if (patientProfileDto.getUsername() == null
|| !patientProfileDto.getUsername().equals(username)) {
return false;
}
if (patientProfileDto.getFirstName() == null
|| !patientProfileDto.getFirstName().equals(
VALID_FIRST_NAME)) {
return false;
}
if (patientProfileDto.getLastName() == null
|| !patientProfileDto.getLastName().equals(
VALID_LAST_NAME)) {
return false;
}
if (patientProfileDto.getEmail() == null
|| !patientProfileDto.getEmail().equals(VALID_EMAIL)) {
return false;
}
if (patientProfileDto.getAdministrativeGenderCode() == null
|| !patientProfileDto.getAdministrativeGenderCode()
.equals(VALID_GENDER_CODE)) {
return false;
}
return true;
}
};
verify(patientService, times(1)).updatePatient(
org.mockito.Matchers.argThat(patientProfileArgumentMatcher));
}
}