private PersonMergeLog mergeAndRetrieveAudit(Patient preferred, Patient notPreferred) throws SerializationException { patientService.mergePatients(preferred, notPreferred); List<PersonMergeLog> result = personService.getAllPersonMergeLogs(true); Assert.assertTrue("person merge was not audited", result.size() > 0); return result.get(0); }
@Test public void mergePatients_shouldMergePatientNames() throws Exception { executeDataSet(PATIENT_MERGE_XML); Patient preferredPatient = patientService.getPatient(10001); Patient nonPreferredPatient = patientService.getPatient(10000); patientService.mergePatients(preferredPatient, nonPreferredPatient); assertThat(preferredPatient.getAddresses().size(), equalTo(2)); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldNotCopyOverRelationshipsThatAreOnlyBetweenThePreferredAndNotpreferredPatient() throws Exception { executeDataSet(PATIENT_RELATIONSHIPS_XML); Patient preferred = patientService.getPatient(999); Patient notPreferred = patientService.getPatient(2); voidOrders(Collections.singleton(notPreferred)); patientService.mergePatients(preferred, notPreferred); }
/** * @see PatientServiceImpl#mergePatients(Patient,Patient) */ @Test(expected = APIException.class) public void mergePatients_shouldNotMergePatientWithItself() throws Exception { Context.getPatientService().mergePatients(new Patient(2), new Patient(2)); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldVoidAllRelationshipsForNonPreferredPatient() throws Exception { executeDataSet(PATIENT_RELATIONSHIPS_XML); Patient preferred = patientService.getPatient(999); Patient notPreferred = patientService.getPatient(2); voidOrders(Collections.singleton(notPreferred)); patientService.mergePatients(preferred, notPreferred); List<Relationship> rels = personService.getRelationshipsByPerson(notPreferred); assertTrue("there should not be any relationships for non preferred", rels.isEmpty()); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldCopyNonvoidedAddressesToPreferredPatient() throws Exception { Patient preferred = patientService.getPatient(7); Patient notPreferred = patientService.getPatient(8); patientService.mergePatients(preferred, notPreferred); // make sure one of their addresses has the city of "Jabali" boolean found = false; for (PersonAddress pa : preferred.getAddresses()) { if (pa.getCityVillage().equals("Jabali")) { found = true; } } Assert.assertTrue("odd, user 7 didn't get user 8's address", found); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldCopyNonvoidedNamesToPreferredPatient() throws Exception { Patient preferred = patientService.getPatient(7); Patient notPreferred = patientService.getPatient(8); patientService.mergePatients(preferred, notPreferred); // make sure one of their addresses has the first name of "Anet" boolean found = false; for (PersonName pn : preferred.getNames()) { if (pn.getGivenName().equals("Anet")) { found = true; } } Assert.assertTrue("odd, user 7 didn't get user 8's names", found); }
/** * @see PatientService#mergePatients(org.openmrs.Patient, org.openmrs.Patient) */ @Test public void mergePatients_shouldNotFailIfOnePatientHasActiveOrder() throws Exception { Patient preferredPatient = patientService.getPatient(2); Patient notPreferredPatient = patientService.getPatient(7); voidOrders(Collections.singleton(notPreferredPatient)); assertTrue("Test pre-request: No Active Drug order in " + preferredPatient, hasActiveOrderOfType(preferredPatient, "Drug order")); assertFalse("Test pre-request: At least one Active Drug order in " + notPreferredPatient, hasActiveOrderOfType(notPreferredPatient, "Drug order")); patientService.mergePatients(preferredPatient, notPreferredPatient); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldChangeUserRecordsOfNonPreferredPersonToPreferredPerson() throws Exception { executeDataSet(USERS_WHO_ARE_PATIENTS_XML); Patient notPreferred = patientService.getPatient(2); voidOrders(Collections.singleton(notPreferred)); Context.getPatientService().mergePatients(patientService.getPatient(6), notPreferred); User user = Context.getUserService().getUser(2); Assert.assertEquals(6, user.getPerson().getId().intValue()); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldVoidNonPreferredPersonObject() throws Exception { Patient notPreferred = patientService.getPatient(2); voidOrders(Collections.singleton(notPreferred)); Context.getPatientService().mergePatients(patientService.getPatient(6), notPreferred); Assert.assertTrue(Context.getPersonService().getPerson(2).getVoided()); }
@Test public void mergePatients_shouldMergeAllNonPreferredPatientsInTheTheNotPreferredListToPreferredPatient() throws Exception { Patient preferred = patientService.getPatient(6); List<Patient> notPreferred = new ArrayList<>(); notPreferred.add(patientService.getPatient(7)); notPreferred.add(patientService.getPatient(8)); voidOrders(notPreferred); patientService.mergePatients(preferred, notPreferred); Assert.assertFalse(patientService.getPatient(6).getVoided()); Assert.assertTrue(patientService.getPatient(7).getVoided()); Assert.assertTrue(patientService.getPatient(8).getVoided()); }
@Test public void mergePatients_shouldMaintainSimilarButDifferentNames() throws Exception { executeDataSet(PATIENT_MERGE_XML); Patient preferredPatient = patientService.getPatient(10000); Patient nonPreferredPatient = patientService.getPatient(10001); patientService.mergePatients(preferredPatient, nonPreferredPatient); Set<PersonName> names = preferredPatient.getNames(); if ((PersonName.getFormat()).equals(OpenmrsConstants.PERSON_NAME_FORMAT_LONG)) { assertThat(names, containsFullName("President John Fitzgerald Kennedy Esq.")); } else { assertThat(names, containsFullName("John Fitzgerald Kennedy")); } }
patientService.mergePatients(preferred, notPreferred);
/** * @see PatientService#mergePatients(Patient, Patient) */ @Test public void mergePatients_shouldCopyNonvoidedIdentifiersToPreferredPatient() throws Exception { Patient preferred = patientService.getPatient(7); Patient notPreferred = patientService.getPatient(8); PatientIdentifier nonvoidedPI = null; PatientIdentifier voidedPI = null; for (PatientIdentifier patientIdentifier : notPreferred.getIdentifiers()) { if (patientIdentifier.getIdentifier().equals("7TU-8")) { nonvoidedPI = patientIdentifier; } if (patientIdentifier.getIdentifier().equals("ABC123")) { voidedPI = patientIdentifier; } } patientService.mergePatients(preferred, notPreferred); Assert.assertNotNull(nonvoidedPI); Assert.assertTrue(contains(new ArrayList<>(preferred.getIdentifiers()), nonvoidedPI.getIdentifier())); Assert.assertNotNull(voidedPI); Assert.assertFalse(contains(new ArrayList<>(preferred.getIdentifiers()), voidedPI.getIdentifier())); }
/** * @see PatientService#mergePatients(Patient,Patient) */ @Test public void mergePatients_shouldOnlyMarkAddressesOfPreferredPatientAsPreferred() throws Exception { Patient preferred = patientService.getPatient(7); Patient notPreferred = patientService.getPatient(8); // since the test data has no preferred addresses, we need to mark addresses to preferred to set up the test preferred.getPersonAddress().setPreferred(true); notPreferred.getPersonAddress().setPreferred(true); patientService.savePatient(preferred); patientService.savePatient(notPreferred); patientService.mergePatients(preferred, notPreferred); Assert.assertThat(preferred.getAddresses().size(), is(2)); // make sure only the address from the preferred patient is marked as preferred for (PersonAddress pa : preferred.getAddresses()) { if (pa.getCityVillage().equals("Jabali")) { Assert.assertFalse(pa.getPreferred()); } } }
/** * @see PatientService#mergePatients(org.openmrs.Patient, org.openmrs.Patient) */ @Test public void mergePatients_shouldMoveAllObsWithSameHierarchy() throws Exception { executeDataSet(PATIENT_MERGE_OBS_WITH_GROUP_MEMBER); Patient notPreffered = patientService.getPatient(11); Patient preffered = patientService.getPatient(21); EncounterService encounterService = Context.getEncounterService(); assertEquals(57, encounterService.getEncountersByPatient(notPreffered).get(0).getId().intValue()); assertEquals(3, encounterService.getEncounter(57).getAllObs(false).size()); assertEquals(4, encounterService.getEncounter(57).getAllObs(true).size()); assertEquals(1, encounterService.getEncounter(57).getObsAtTopLevel(false).size()); assertEquals(1, encounterService.getEncounter(57).getObsAtTopLevel(true).size()); patientService.mergePatients(preffered, notPreffered); assertEquals(3, encounterService.getEncounter(57).getAllObs(false).size()); assertEquals(8, encounterService.getEncounter(57).getAllObs(true).size()); assertEquals(1, encounterService.getEncounter(57).getObsAtTopLevel(false).size()); assertEquals(2, encounterService.getEncounter(57).getObsAtTopLevel(true).size()); }
patientService.mergePatients(preferred, notPreferred);
@Test public void mergePatients_shouldFailIfMultiplePatientsHaveActiveOrderOfSameType() throws Exception { expectedException.expect(APIException.class); String message = Context.getMessageSourceService().getMessage("Patient.merge.cannotHaveSameTypeActiveOrders", new Object[] { "2", "7", "Drug order" }, Context.getLocale()); expectedException.expectMessage(is(message)); Patient preferredPatient = patientService.getPatient(2); Patient notPreferredPatient = patientService.getPatient(7); assertTrue("Test pre-request: No Active Drug order in " + preferredPatient, hasActiveOrderOfType(preferredPatient, "Drug order")); assertTrue("Test pre-request: No Active Drug order in " + notPreferredPatient, hasActiveOrderOfType(preferredPatient, "Drug order")); patientService.mergePatients(preferredPatient, notPreferredPatient); }
@Test public void mergePatients_shouldMaintainSimilarButDifferentAddresses() throws Exception { executeDataSet(PATIENT_MERGE_XML); Patient preferredPatient = patientService.getPatient(10000); Patient nonPreferredPatient = patientService.getPatient(10001); patientService.mergePatients(preferredPatient, nonPreferredPatient); Set<PersonAddress> addresses = preferredPatient.getAddresses(); assertThat( addresses, containsAddress("a1:Apartment ABC, a2:123 fake st, cv:Faketown, sp:null, c:null, cd:null, nc:null, pc:1234, lat:null, long:null")); assertThat( addresses, containsAddress("a1:Apartment ABC, a2:123 fake st, cv:Faketown, sp:Fakeland, c:null, cd:null, nc:null, pc:null, lat:null, long:null")); }
/** * @see PatientService#mergePatients(org.openmrs.Patient, org.openmrs.Patient) */ @Test public void mergePatients_shouldNotFailIfMultiplePatientsHaveActiveOrderOfDifferentTypes() throws Exception { Patient preferredPatient = patientService.getPatient(2); Patient notPreferredPatient = patientService.getPatient(7); OrderType DrugOrder = Context.getOrderService().getOrderTypeByName("Drug order"); voidOrdersForType(Collections.singleton(preferredPatient), DrugOrder); assertFalse("Test pre-request: No Active Drug order in " + preferredPatient, hasActiveOrderOfType(preferredPatient, "Drug order")); assertTrue("Test pre-request: At least one Active Test order in " + preferredPatient, hasActiveOrderOfType(preferredPatient, "Test order")); assertTrue("Test pre-request: At least one Active Drug order in " + notPreferredPatient, hasActiveOrderOfType(notPreferredPatient, "Drug order")); assertFalse("Test pre-request: No Active Test order in " + notPreferredPatient, hasActiveOrderOfType(notPreferredPatient, "Test order")); patientService.mergePatients(preferredPatient, notPreferredPatient); }