@Test
public void createNewOrderFromEtOrder() throws Exception {
Provider provider = mock(Provider.class);
handleEncounterProvider(provider);
Concept mrsBloodConcept = mock(Concept.class);
when(conceptService.getConceptByUuid("bloodConceptUuid")).thenReturn(mrsBloodConcept);
Date currentDate = new Date();
EncounterTransaction.Concept blood =
new EncounterTransaction.Concept("bloodConceptUuid", "blood");
EncounterTransaction.Order etOrder = new EncounterTransaction.Order();
etOrder.setConcept(blood);
etOrder.setDateCreated(currentDate);
OpenMRSOrderMapper orderMapper = new OpenMRSOrderMapper(orderService, conceptService);
Order order = orderMapper.map(etOrder, encounter);
Assert.assertEquals(encounter, order.getEncounter());
Assert.assertEquals(mrsBloodConcept, order.getConcept());
Assert.assertEquals(provider, order.getOrderer());
}
@Test
public void createRevisedOrderFromEtOrder() {
Provider provider = mock(Provider.class);
handleEncounterProvider(provider);
Order originalOrder = new Order();
when(orderService.getOrderByUuid("previousOrderUuid")).thenReturn(originalOrder);
Date currentDate = new Date();
EncounterTransaction.Order etOrder = new EncounterTransaction.Order();
etOrder.setUuid(null);
etOrder.setPreviousOrderUuid("previousOrderUuid");
etOrder.setAutoExpireDate(currentDate);
etOrder.setCommentToFulfiller("Comment");
OpenMRSOrderMapper orderMapper = new OpenMRSOrderMapper(orderService, conceptService);
Order order = orderMapper.map(etOrder, encounter);
verify(orderService).getOrderByUuid("previousOrderUuid");
Assert.assertEquals(encounter, order.getEncounter());
Assert.assertEquals("Comment", order.getCommentToFulfiller());
Assert.assertEquals(currentDate, order.getAutoExpireDate());
Assert.assertEquals(provider, order.getOrderer());
}
@Test
public void mapOrdersWithObs_shouldMapLabTestWithoutResultToLabOrderResult() {
EncounterTransaction.Order order1 =
createOrder("uuid1", "concept1", Order.Action.NEW.toString(), null);
List<EncounterTransaction.Order> testOrders = Arrays.asList(order1);
Map<String, Encounter> orderToEncounterMapping = new HashMap<>();
orderToEncounterMapping.put(order1.getUuid(), encounter);
List<LabOrderResult> results =
labOrderResultsServiceImpl.mapOrdersWithObs(
testOrders,
new ArrayList<EncounterTransaction.Observation>(),
orderToEncounterMapping,
new HashMap(),
new HashMap());
assertEquals(1, results.size());
}
@Test
public void mapOrdersWithObs_shouldMapAllObservationsToLabOrderResults() {
EncounterTransaction.Order order1 =
createOrder("uuid1", "concept1", Order.Action.NEW.toString(), null);
EncounterTransaction.Order order2 =
createOrder("uuid2", "concept2", Order.Action.REVISE.toString(), null);
List<EncounterTransaction.Order> testOrders = Arrays.asList(order1, order2);
EncounterTransaction.Observation order1_Obs1 = createObservation("obsuuid1", order1.getUuid());
EncounterTransaction.Observation order1_Obs2 = createObservation("obsuuid2", order1.getUuid());
EncounterTransaction.Observation order2_Obs1 = createObservation("obsuuid3", order2.getUuid());
List<EncounterTransaction.Observation> observations =
Arrays.asList(order1_Obs1, order1_Obs2, order2_Obs1);
Map<String, Encounter> orderToEncounterMapping = new HashMap<>();
orderToEncounterMapping.put(order1.getUuid(), encounter);
orderToEncounterMapping.put(order2.getUuid(), encounter);
Map<String, Encounter> observationToEncounterMapping = new HashMap<>();
observationToEncounterMapping.put(order1_Obs1.getUuid(), encounter);
observationToEncounterMapping.put(order1_Obs2.getUuid(), encounter);
observationToEncounterMapping.put(order2_Obs1.getUuid(), encounter);
List<LabOrderResult> results =
labOrderResultsServiceImpl.mapOrdersWithObs(
testOrders,
observations,
orderToEncounterMapping,
observationToEncounterMapping,
new HashMap());
assertEquals(3, results.size());
}
private EncounterTransaction.Order createOrder(
String uuid, String conceptName, String action, Date dateStopped) {
EncounterTransaction.Order order = new EncounterTransaction.Order();
EncounterTransaction.Concept concept = new EncounterTransaction.Concept();
concept.setName(conceptName);
order.setConcept(concept);
order.setAction(action);
order.setDateStopped(dateStopped);
order.setUuid(uuid);
order.setOrderType(LabOrderResultsServiceImpl.LAB_ORDER_TYPE);
return order;
}
@Override
public EncounterTransaction.Order mapOrder(Order order) {
EncounterTransaction.Order emrOrder = new EncounterTransaction.Order();
emrOrder.setUuid(order.getUuid());
emrOrder.setConcept(conceptMapper.map(order.getConcept()));
emrOrder.setOrderType(order.getOrderType().getName());
emrOrder.setInstructions(order.getInstructions());
emrOrder.setDateCreated(order.getDateCreated());
emrOrder.setDateChanged(order.getDateChanged());
emrOrder.setDateStopped(order.getDateStopped());
emrOrder.setOrderNumber(order.getOrderNumber());
emrOrder.setCommentToFulfiller(order.getCommentToFulfiller());
emrOrder.setAction(order.getAction().name());
org.openmrs.Order previousOrder = order.getPreviousOrder();
if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) {
emrOrder.setPreviousOrderUuid(previousOrder.getUuid());
}
return emrOrder;
}
