@Override protected PatientIdentifierType getExistingObject() { return patientService.getPatientIdentifierType(EXISTING_ID); } }
@Override protected PatientIdentifierType getObjectById(Integer id) { return Context.getPatientService().getPatientIdentifierType(id); }
/** * @see PatientService#getPatientIdentifierType(Integer) */ @Test public void getPatientIdentifierType_shouldFetchPatientIdentifierWithGivenPatientIdentifierTypeId() throws Exception { PatientIdentifierType identifierType = Context.getPatientService().getPatientIdentifierType(1); Assert.assertNotNull(identifierType); Assert.assertTrue(identifierType.getClass().isAssignableFrom(PatientIdentifierType.class)); }
/** * @see PatientService#savePatientIdentifierType(PatientIdentifierType) */ @Test public void savePatientIdentifierType_shouldUpdateExistingType() throws Exception { PatientIdentifierType type = patientService.getPatientIdentifierType(1); type.setName("SOME NEW NAME"); patientService.savePatientIdentifierType(type); PatientIdentifierType newerPatientIdentifierType = patientService.getPatientIdentifierType(1); assertEquals("SOME NEW NAME", newerPatientIdentifierType.getName()); }
/** * @see PatientService#getPatientIdentifierType(Integer) */ @Test public void getPatientIdentifierType_shouldReturnNullWhenPatientIdentifierIdentifierDoesNotExist() throws Exception { PatientIdentifierType identifierType = Context.getPatientService().getPatientIdentifierType(10000); Assert.assertNull(identifierType); }
@Test(expected = APIException.class) public void retirePatientIdentifierType_shouldThrowAPIExceptionWhenNullReasonIsPassed() throws Exception { PatientService ps = Context.getPatientService(); PatientIdentifierType pit = ps.getPatientIdentifierType(1); ps.retirePatientIdentifierType(pit, null); }
/** * @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier) */ @Test public void isIdentifierInUseByAnotherPatient_shouldReturnTrueWhenPatientIdentifierDoesNotContainAPatientAndAPatientHasThisId() throws Exception { PatientIdentifierType pit = patientService.getPatientIdentifierType(1); PatientIdentifier patientIdentifier = new PatientIdentifier("7TU-8", pit, null); Assert.assertTrue(patientService.isIdentifierInUseByAnotherPatient(patientIdentifier)); }
@Test(expected = PatientIdentifierTypeLockedException.class) public void retirePatientIdentifierType_shouldThrowErrorWhenTryingToRetireAPatientIdentifierTypeWhilePatientIdentifierTypesAreLocked() throws Exception { PatientService ps = Context.getPatientService(); createPatientIdentifierTypeLockedGPAndSetValue("true"); PatientIdentifierType pit = ps.getPatientIdentifierType(1); ps.retirePatientIdentifierType(pit, "Retire test"); }
/** * @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier) */ @Test public void isIdentifierInUseByAnotherPatient_shouldReturnFalseWhenPatientIdentifierDoesNotContainAPatientAndNoPatientHasThisId() throws Exception { PatientIdentifierType pit = patientService.getPatientIdentifierType(1); PatientIdentifier patientIdentifier = new PatientIdentifier("Nobody could possibly have this identifier", pit, null); Assert.assertFalse(patientService.isIdentifierInUseByAnotherPatient(patientIdentifier)); }
@Test(expected = PatientIdentifierTypeLockedException.class) public void purgePatientIdentifierType_shouldThrowErrorWhenTryingToDeleteAPatientIdentifierTypeWhilePatientIdentifierTypesAreLocked() throws Exception { PatientService ps = Context.getPatientService(); createPatientIdentifierTypeLockedGPAndSetValue("true"); PatientIdentifierType pit = ps.getPatientIdentifierType(1); ps.purgePatientIdentifierType(pit); }
/** * @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier) */ @Test public void isIdentifierInUseByAnotherPatient_shouldIgnoreVoidedPatientIdentifiers() throws Exception { PatientIdentifierType pit = patientService.getPatientIdentifierType(2); PatientIdentifier patientIdentifier = new PatientIdentifier("ABC123", pit, null); Assert.assertFalse(patientService.isIdentifierInUseByAnotherPatient(patientIdentifier)); }
@Test(expected = PatientIdentifierTypeLockedException.class) public void unretirePatientIdentifierType_shouldThrowErrorWhenTryingToUnretireAPatientIdentifierTypeWhilePatientIdentifierTypesAreLocked() throws Exception { PatientService ps = Context.getPatientService(); createPatientIdentifierTypeLockedGPAndSetValue("true"); PatientIdentifierType pit = ps.getPatientIdentifierType(1); ps.unretirePatientIdentifierType(pit); }
@Test public void getPatients_shouldFindIdentifierIgnoringCase() { Patient patient = patientService.getPatient(2); PatientIdentifier patientIdentifier = new PatientIdentifier("AS_567", patientService.getPatientIdentifierType(5), locationService.getLocation(1)); patient.addIdentifier(patientIdentifier); patientService.savePatient(patient); updateSearchIndex(); List<Patient> patients = patientService.getPatients("as_567"); assertThat(patients, contains(patient)); }
@Test(expected = PatientIdentifierTypeLockedException.class) public void savePatientIdentifierType_shouldThrowErrorWhenTryingToSaveAPatientIdentifierTypeWhilePatientIdentifierTypesAreLocked() throws Exception { PatientService ps = Context.getPatientService(); createPatientIdentifierTypeLockedGPAndSetValue("true"); PatientIdentifierType pit = ps.getPatientIdentifierType(1); pit.setDescription("test"); ps.savePatientIdentifierType(pit); }
/** * @see PatientService#purgePatientIdentifierType(PatientIdentifierType) */ @Test public void purgePatientIdentifierType_shouldDeleteTypeFromDatabase() throws Exception { PatientIdentifierType patientIdentifierType = new PatientIdentifierType(); patientIdentifierType.setName("testing"); patientIdentifierType.setDescription("desc"); patientIdentifierType.setRequired(false); patientService.savePatientIdentifierType(patientIdentifierType); PatientIdentifierType type = patientService.getPatientIdentifierType(patientIdentifierType.getId()); patientService.purgePatientIdentifierType(type); assertNull(patientService.getPatientIdentifierType(patientIdentifierType.getId())); }
/** * @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier) */ @Test public void isIdentifierInUseByAnotherPatient_shouldReturnFalseWhenPatientIdentifierContainsAPatientAndNoOtherPatientHasThisId() throws Exception { PatientIdentifierType pit = patientService.getPatientIdentifierType(1); PatientIdentifier patientIdentifier = new PatientIdentifier("Nobody could possibly have this identifier", pit, null); patientIdentifier.setPatient(patientService.getPatient(2)); Assert.assertFalse(patientService.isIdentifierInUseByAnotherPatient(patientIdentifier)); }
/** * @see PatientService#isIdentifierInUseByAnotherPatient(PatientIdentifier) */ @Test public void isIdentifierInUseByAnotherPatient_shouldReturnTrueWhenPatientIdentifierContainsAPatientAndAnotherPatientHasThisId() throws Exception { PatientIdentifierType pit = patientService.getPatientIdentifierType(1); PatientIdentifier patientIdentifier = new PatientIdentifier("7TU-8", pit, null); patientIdentifier.setPatient(patientService.getPatient(2)); Assert.assertTrue(patientService.isIdentifierInUseByAnotherPatient(patientIdentifier)); }
/** * @see PatientService#getCountOfPatients(String) */ @Test public void getCountOfPatients_shouldReturnTheRightCountOfPatientsWithAMatchingIdentifierWithNoDigits() throws Exception { final String identifier = "XYZ"; Patient patient = patientService.getPatient(2); Assert.assertEquals(0, patientService.getCountOfPatients(identifier).intValue()); PatientIdentifier pId = new PatientIdentifier(identifier, patientService.getPatientIdentifierType(5), locationService.getLocation(1)); patient.addIdentifier(pId); patientService.savePatient(patient); updateSearchIndex(); Assert.assertEquals(1, patientService.getCountOfPatients(identifier).intValue()); }
/** * @see PatientService#savePatientIdentifierType(PatientIdentifierType) */ @Test public void savePatientIdentifierType_shouldCreateNewType() throws Exception { PatientIdentifierType patientIdentifierType = new PatientIdentifierType(); patientIdentifierType.setName("testing"); patientIdentifierType.setDescription("desc"); patientIdentifierType.setRequired(false); patientService.savePatientIdentifierType(patientIdentifierType); PatientIdentifierType newPatientIdentifierType = patientService.getPatientIdentifierType(patientIdentifierType .getPatientIdentifierTypeId()); assertNotNull(newPatientIdentifierType); }
/** * @see PatientService#savePatientIdentifierType(PatientIdentifierType) */ @Test public void savePatientIdentifierType_shouldCreateNewPatientIdentifierType() throws Exception { PatientIdentifierType identifierType = new PatientIdentifierType(); identifierType.setName("test"); identifierType.setDescription("test description"); identifierType.setRequired(false); Assert.assertNull(identifierType.getPatientIdentifierTypeId()); patientService.savePatientIdentifierType(identifierType); PatientIdentifierType savedIdentifierType = patientService.getPatientIdentifierType(identifierType .getPatientIdentifierTypeId()); assertNotNull(savedIdentifierType); }