<commit_before>/**
 * The contents of this file are subject to the OpenMRS Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://license.openmrs.org
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.
 */
package org.openmrs;

import static org.hamcrest.Matchers.hasItems;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.apache.commons.collections.CollectionUtils;
import org.hamcrest.Matchers;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.openmrs.api.APIException;
import org.openmrs.api.ConceptService;
import org.openmrs.api.EncounterService;
import org.openmrs.api.OrderService;
import org.openmrs.api.PatientService;
import org.openmrs.api.ProviderService;
import org.openmrs.api.context.Context;
import org.openmrs.order.OrderUtilTest;
import org.openmrs.test.BaseContextSensitiveTest;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * Contains end to end tests for order entry operations i.g placing, discontinuing revising an order
 */
public class OrderEntryIntegrationTest extends BaseContextSensitiveTest {
	
	protected static final String ORDER_ENTRY_DATASET_XML = "org/openmrs/api/include/OrderEntryIntegrationTest-other.xml";
	
	@Autowired
	private OrderService orderService;
	
	@Autowired
	private PatientService patientService;
	
	@Autowired
	private ConceptService conceptService;
	
	@Autowired
	private ProviderService providerService;
	
	@Autowired
	private EncounterService encounterService;
	
	@Rule
	public ExpectedException expectedException = ExpectedException.none();
	
	@Test
	public void shouldGetTheActiveOrdersForAPatient() {
		Patient patient = patientService.getPatient(2);
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(5, activeOrders.size());
		Order[] expectedOrders = { orderService.getOrder(3), orderService.getOrder(5), orderService.getOrder(7),
		        orderService.getOrder(222), orderService.getOrder(444) };
		assertThat(activeOrders, hasItems(expectedOrders));
	}
	
	@Test
	public void shouldGetTheActiveDrugOrdersForAPatient() {
		Patient patient = patientService.getPatient(2);
		List<Order> activeDrugOrders = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Drug order"),
		    null, null);
		assertEquals(4, activeDrugOrders.size());
		Order[] expectedDrugOrders = { orderService.getOrder(222), orderService.getOrder(3), orderService.getOrder(444),
		        orderService.getOrder(5) };
		assertThat(activeDrugOrders, hasItems(expectedDrugOrders));
	}
	
	@Test
	public void shouldPlaceADrugOrder() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		Patient patient = patientService.getPatient(7);
		CareSetting careSetting = orderService.getCareSetting(1);
		int activeDrugOrderCount = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Drug order"),
		    careSetting, null).size();
		
		//place drug order
		DrugOrder order = new DrugOrder();
		Encounter encounter = encounterService.getEncounter(3);
		order.setEncounter(encounter);
		order.setPatient(patient);
		order.setCareSetting(careSetting);
		order.setOrderer(Context.getProviderService().getProvider(1));
		order.setDateActivated(encounter.getEncounterDatetime());
		order.setDrug(conceptService.getDrug(2));
		order.setDosingType(SimpleDosingInstructions.class);
		order.setDose(300.0);
		order.setDoseUnits(conceptService.getConcept(50));
		order.setQuantity(20.0);
		order.setQuantityUnits(conceptService.getConcept(51));
		order.setFrequency(orderService.getOrderFrequency(3000));
		order.setRoute(conceptService.getConcept(22));
		order.setNumRefills(10);
		
		orderService.saveOrder(order, null);
		List<Order> activeOrders = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Drug order"),
		    careSetting, null);
		assertEquals(++activeDrugOrderCount, activeOrders.size());
		assertTrue(activeOrders.contains(order));
	}
	
	@Test
	public void shouldPlaceATestOrder() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		Patient patient = patientService.getPatient(7);
		CareSetting careSetting = orderService.getCareSetting(1);
		int activeTestOrderCount = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Test order"),
		    careSetting, null).size();
		
		//place test order
		TestOrder order = new TestOrder();
		order.setPatient(patient);
		order.setConcept(conceptService.getConcept(5497));
		order.setOrderer(providerService.getProvider(1));
		order.setCareSetting(careSetting);
		Encounter encounter = encounterService.getEncounter(3);
		order.setEncounter(encounter);
		order.setDateActivated(encounter.getEncounterDatetime());
		order.setClinicalHistory("Patient had a negative reaction to the test in the past");
		order.setFrequency(orderService.getOrderFrequency(3000));
		order.setSpecimenSource(conceptService.getConcept(22));
		order.setNumberOfRepeats(3);
		
		orderService.saveOrder(order, null);
		List<Order> activeOrders = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Test order"),
		    careSetting, null);
		assertEquals(++activeTestOrderCount, activeOrders.size());
		assertTrue(activeOrders.contains(order));
	}
	
	@Test
	public void shouldDiscontinueAnActiveOrder() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		executeDataSet("org/openmrs/api/include/OrderServiceTest-discontinueReason.xml");
		
		Order firstOrderToDiscontinue = orderService.getOrder(3);
		Encounter encounter = encounterService.getEncounter(3);
		assertTrue(OrderUtilTest.isActiveOrder(firstOrderToDiscontinue, null));
		Patient patient = firstOrderToDiscontinue.getPatient();
		int ordersCount = orderService.getActiveOrders(patient, null, null, null).size();
		
		Concept discontinueReason = Context.getConceptService().getConcept(1);
		Provider orderer = providerService.getProvider(1);
		Order discontinuationOrder1 = orderService.discontinueOrder(firstOrderToDiscontinue, discontinueReason, null,
		    orderer, encounter);
		assertEquals(firstOrderToDiscontinue, discontinuationOrder1.getPreviousOrder());
		
		//Lets discontinue another order with reason being a string instead of concept
		Order secondOrderToDiscontinue = orderService.getOrder(5);
		assertEquals(patient, secondOrderToDiscontinue.getPatient());
		assertTrue(OrderUtilTest.isActiveOrder(secondOrderToDiscontinue, null));
		Order discontinuationOrder2 = orderService.discontinueOrder(secondOrderToDiscontinue, "Testing", null, orderer,
		    encounter);
		assertEquals(secondOrderToDiscontinue, discontinuationOrder2.getPreviousOrder());
		
		//Lets discontinue another order by saving a DC order
		Order thirdOrderToDiscontinue = orderService.getOrder(7);
		assertTrue(OrderUtilTest.isActiveOrder(thirdOrderToDiscontinue, null));
		Order discontinuationOrder = thirdOrderToDiscontinue.cloneForDiscontinuing();
		discontinuationOrder.setOrderer(orderer);
		discontinuationOrder.setEncounter(encounterService.getEncounter(6));
		orderService.saveOrder(discontinuationOrder, null);
		
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(ordersCount - 3, activeOrders.size());
		assertFalse(activeOrders.contains(firstOrderToDiscontinue));
		assertFalse(activeOrders.contains(secondOrderToDiscontinue));
		assertFalse(activeOrders.contains(thirdOrderToDiscontinue));
	}
	
	@Test
	public void shouldReviseAnOrder() throws Exception {
		Order originalOrder = orderService.getOrder(111);
		assertTrue(OrderUtilTest.isActiveOrder(originalOrder, null));
		final Patient patient = originalOrder.getPatient();
		List<Order> originalActiveOrders = orderService.getActiveOrders(patient, null, null, null);
		final int originalOrderCount = originalActiveOrders.size();
		assertTrue(originalActiveOrders.contains(originalOrder));
		
		Order revisedOrder = originalOrder.cloneForRevision();
		revisedOrder.setInstructions("Take after a meal");
		revisedOrder.setDateActivated(new Date());
		revisedOrder.setOrderer(providerService.getProvider(1));
		revisedOrder.setEncounter(encounterService.getEncounter(3));
		orderService.saveOrder(revisedOrder, null);
		
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(originalOrderCount, activeOrders.size());
		assertEquals(revisedOrder.getDateActivated(), DateUtils.addSeconds(originalOrder.getDateStopped(), 1));
		assertFalse(OrderUtilTest.isActiveOrder(originalOrder, null));
	}
	
	/**
	 * @verifies void an order
	 * @see OrderService#voidOrder(org.openmrs.Order, String)
	 */
	@Test
	public void shouldVoidAnOrderAndFlushSuccessfully() throws Exception {
		Order order = orderService.getOrder(1);
		assertFalse(order.getVoided());
		assertNull(order.getDateVoided());
		assertNull(order.getVoidedBy());
		assertNull(order.getVoidReason());
		
		orderService.voidOrder(order, "None");
		//forces hibernate interceptors to get invoked
		Context.flushSession();
		assertTrue(order.getVoided());
		assertNotNull(order.getDateVoided());
		assertNotNull(order.getVoidedBy());
		assertNotNull(order.getVoidReason());
	}
	
	/**
	 * @verifies unvoid an order
	 * @see OrderService#unvoidOrder(org.openmrs.Order)
	 */
	@Test
	public void shouldUnvoidAnOrderAndFlushSuccessfully() throws Exception {
		Order order = orderService.getOrder(8);
		assertTrue(order.getVoided());
		assertNotNull(order.getDateVoided());
		assertNotNull(order.getVoidedBy());
		assertNotNull(order.getVoidReason());
		
		orderService.unvoidOrder(order);
		Context.flushSession();
		assertFalse(order.getVoided());
		assertNull(order.getDateVoided());
		assertNull(order.getVoidedBy());
		assertNull(order.getVoidReason());
	}
	
	@Test
	public void shouldDiscontinueAnActiveOrderAndFlushSuccessfully() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		executeDataSet("org/openmrs/api/include/OrderServiceTest-discontinueReason.xml");
		
		Order firstOrderToDiscontinue = orderService.getOrder(3);
		Encounter encounter = encounterService.getEncounter(3);
		assertTrue(OrderUtilTest.isActiveOrder(firstOrderToDiscontinue, null));
		
		Concept discontinueReason = Context.getConceptService().getConcept(1);
		Provider orderer = providerService.getProvider(1);
		Order discontinuationOrder1 = orderService.discontinueOrder(firstOrderToDiscontinue, discontinueReason, null,
		    orderer, encounter);
		Context.flushSession();
		assertEquals(firstOrderToDiscontinue, discontinuationOrder1.getPreviousOrder());
	}
	
	@Test
	public void shouldReviseAnOrderAndFlushSuccessfully() throws Exception {
		Order originalOrder = orderService.getOrder(111);
		assertTrue(OrderUtilTest.isActiveOrder(originalOrder, null));
		final Patient patient = originalOrder.getPatient();
		List<Order> originalActiveOrders = orderService.getActiveOrders(patient, null, null, null);
		final int originalOrderCount = originalActiveOrders.size();
		assertTrue(originalActiveOrders.contains(originalOrder));
		
		Order revisedOrder = originalOrder.cloneForRevision();
		revisedOrder.setInstructions("Take after a meal");
		revisedOrder.setDateActivated(new Date());
		revisedOrder.setOrderer(providerService.getProvider(1));
		revisedOrder.setEncounter(encounterService.getEncounter(3));
		orderService.saveOrder(revisedOrder, null);
		Context.flushSession();
		
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(originalOrderCount, activeOrders.size());
		assertFalse(OrderUtilTest.isActiveOrder(originalOrder, null));
	}
	
	@Test
	public void shouldFailIfAnEditedOrderIsFlushed() throws Exception {
		Encounter encounter = encounterService.getEncounter(3);
		assertFalse(encounter.getOrders().isEmpty());
		encounter.getOrders().iterator().next().setInstructions("new");
		expectedException.expect(APIException.class);
		expectedException.expectMessage(Matchers.is("editing.fields.not.allowed"));
		encounterService.saveEncounter(encounter);
		Context.flushSession();
	}
	
	/**
	 * This test ensures that the getter for previous order field returns objects of the actual sub
	 * types for subclasses instead proxies that are instances of Order
	 * 
	 * @throws Exception
	 */
	@Test
	public void shouldNotReturnAProxyForPreviousOrder() throws Exception {
		Order dcOrder = orderService.getOrder(22);
		Order previousOrder = dcOrder.getPreviousOrder();
		assertNotNull(previousOrder);
		DrugOrder previousDrugOrder = (DrugOrder) previousOrder;
		
		Order testOrder = orderService.getOrder(7);
		Order dcTestOrder = orderService.discontinueOrder(testOrder, "Testing", null, testOrder.getOrderer(), testOrder
		        .getEncounter());
		Context.flushSession();
		Context.clearSession();
		dcTestOrder = (TestOrder) orderService.getOrder(dcTestOrder.getOrderId()).getPreviousOrder();
	}
	
	@Test
	public void shouldAllowEditingADiscontinuationOrder() throws Exception {
		Order originalDCOrder = orderService.getOrder(22);
		assertEquals(Order.Action.DISCONTINUE, originalDCOrder.getAction());
		List<Order> originalPatientOrders = orderService.getAllOrdersByPatient(originalDCOrder.getPatient());
		final Order previousOrder = originalDCOrder.getPreviousOrder();
		assertNotNull(previousOrder);
		final Date newStartDate = originalDCOrder.getEncounter().getEncounterDatetime();
		
		Order newDcOrder = originalDCOrder.cloneForRevision();
		newDcOrder.setEncounter(originalDCOrder.getEncounter());
		newDcOrder.setOrderer(originalDCOrder.getOrderer());
		newDcOrder.setDateActivated(newStartDate);
		orderService.voidOrder(originalDCOrder, "To be replace with a new one");
		assertNull(originalDCOrder.getDateStopped());
		orderService.saveOrder(newDcOrder, null);
		
		//We need to flush so that we ensure the interceptor is okay with all this
		Context.flushSession();
		assertTrue(originalDCOrder.isVoided());
		List<Order> newPatientOrders = orderService.getAllOrdersByPatient(originalDCOrder.getPatient());
		assertEquals(originalPatientOrders.size() + 1, newPatientOrders.size());
		Collection<Order> newOrders = CollectionUtils.disjunction(originalPatientOrders, newPatientOrders);
		assertEquals(1, newOrders.size());
		assertEquals(newOrders.iterator().next().getPreviousOrder(), previousOrder);
	}
	
	@Test
	public void shouldAllowRetrospectiveDataEntryOfOrders() throws Exception {
		Order order = new TestOrder();
		order.setPatient(patientService.getPatient(2));
		order.setCareSetting(orderService.getCareSetting(2));
		order.setConcept(conceptService.getConcept(5089));
		order.setEncounter(encounterService.getEncounter(6));
		order.setOrderer(providerService.getProvider(1));
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_WEEK, -1);
		order.setDateActivated(cal.getTime());
		orderService.saveOrder(order, null);
		
		cal.add(Calendar.HOUR_OF_DAY, -1);
		Date stopDate = cal.getTime();
		Order dcOrder = orderService.discontinueOrder(order, "Testing", stopDate, order.getOrderer(), order.getEncounter());
		assertEquals(stopDate, order.getDateStopped());
		assertEquals(stopDate, dcOrder.getAutoExpireDate());
	}
}
<commit_msg>TRUNK-4580 - Fixing compile error (because I didn't verify the build after a git cherry-pick)<commit_after>/**
 * The contents of this file are subject to the OpenMRS Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://license.openmrs.org
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.
 */
package org.openmrs;

import static org.hamcrest.Matchers.hasItems;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.hamcrest.Matchers;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.openmrs.api.APIException;
import org.openmrs.api.ConceptService;
import org.openmrs.api.EncounterService;
import org.openmrs.api.OrderService;
import org.openmrs.api.PatientService;
import org.openmrs.api.ProviderService;
import org.openmrs.api.context.Context;
import org.openmrs.order.OrderUtilTest;
import org.openmrs.test.BaseContextSensitiveTest;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * Contains end to end tests for order entry operations i.g placing, discontinuing revising an order
 */
public class OrderEntryIntegrationTest extends BaseContextSensitiveTest {
	
	protected static final String ORDER_ENTRY_DATASET_XML = "org/openmrs/api/include/OrderEntryIntegrationTest-other.xml";
	
	@Autowired
	private OrderService orderService;
	
	@Autowired
	private PatientService patientService;
	
	@Autowired
	private ConceptService conceptService;
	
	@Autowired
	private ProviderService providerService;
	
	@Autowired
	private EncounterService encounterService;
	
	@Rule
	public ExpectedException expectedException = ExpectedException.none();
	
	@Test
	public void shouldGetTheActiveOrdersForAPatient() {
		Patient patient = patientService.getPatient(2);
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(5, activeOrders.size());
		Order[] expectedOrders = { orderService.getOrder(3), orderService.getOrder(5), orderService.getOrder(7),
		        orderService.getOrder(222), orderService.getOrder(444) };
		assertThat(activeOrders, hasItems(expectedOrders));
	}
	
	@Test
	public void shouldGetTheActiveDrugOrdersForAPatient() {
		Patient patient = patientService.getPatient(2);
		List<Order> activeDrugOrders = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Drug order"),
		    null, null);
		assertEquals(4, activeDrugOrders.size());
		Order[] expectedDrugOrders = { orderService.getOrder(222), orderService.getOrder(3), orderService.getOrder(444),
		        orderService.getOrder(5) };
		assertThat(activeDrugOrders, hasItems(expectedDrugOrders));
	}
	
	@Test
	public void shouldPlaceADrugOrder() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		Patient patient = patientService.getPatient(7);
		CareSetting careSetting = orderService.getCareSetting(1);
		int activeDrugOrderCount = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Drug order"),
		    careSetting, null).size();
		
		//place drug order
		DrugOrder order = new DrugOrder();
		Encounter encounter = encounterService.getEncounter(3);
		order.setEncounter(encounter);
		order.setPatient(patient);
		order.setCareSetting(careSetting);
		order.setOrderer(Context.getProviderService().getProvider(1));
		order.setDateActivated(encounter.getEncounterDatetime());
		order.setDrug(conceptService.getDrug(2));
		order.setDosingType(SimpleDosingInstructions.class);
		order.setDose(300.0);
		order.setDoseUnits(conceptService.getConcept(50));
		order.setQuantity(20.0);
		order.setQuantityUnits(conceptService.getConcept(51));
		order.setFrequency(orderService.getOrderFrequency(3000));
		order.setRoute(conceptService.getConcept(22));
		order.setNumRefills(10);
		
		orderService.saveOrder(order, null);
		List<Order> activeOrders = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Drug order"),
		    careSetting, null);
		assertEquals(++activeDrugOrderCount, activeOrders.size());
		assertTrue(activeOrders.contains(order));
	}
	
	@Test
	public void shouldPlaceATestOrder() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		Patient patient = patientService.getPatient(7);
		CareSetting careSetting = orderService.getCareSetting(1);
		int activeTestOrderCount = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Test order"),
		    careSetting, null).size();
		
		//place test order
		TestOrder order = new TestOrder();
		order.setPatient(patient);
		order.setConcept(conceptService.getConcept(5497));
		order.setOrderer(providerService.getProvider(1));
		order.setCareSetting(careSetting);
		Encounter encounter = encounterService.getEncounter(3);
		order.setEncounter(encounter);
		order.setDateActivated(encounter.getEncounterDatetime());
		order.setClinicalHistory("Patient had a negative reaction to the test in the past");
		order.setFrequency(orderService.getOrderFrequency(3000));
		order.setSpecimenSource(conceptService.getConcept(22));
		order.setNumberOfRepeats(3);
		
		orderService.saveOrder(order, null);
		List<Order> activeOrders = orderService.getActiveOrders(patient, orderService.getOrderTypeByName("Test order"),
		    careSetting, null);
		assertEquals(++activeTestOrderCount, activeOrders.size());
		assertTrue(activeOrders.contains(order));
	}
	
	@Test
	public void shouldDiscontinueAnActiveOrder() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		executeDataSet("org/openmrs/api/include/OrderServiceTest-discontinueReason.xml");
		
		Order firstOrderToDiscontinue = orderService.getOrder(3);
		Encounter encounter = encounterService.getEncounter(3);
		assertTrue(OrderUtilTest.isActiveOrder(firstOrderToDiscontinue, null));
		Patient patient = firstOrderToDiscontinue.getPatient();
		int ordersCount = orderService.getActiveOrders(patient, null, null, null).size();
		
		Concept discontinueReason = Context.getConceptService().getConcept(1);
		Provider orderer = providerService.getProvider(1);
		Order discontinuationOrder1 = orderService.discontinueOrder(firstOrderToDiscontinue, discontinueReason, null,
		    orderer, encounter);
		assertEquals(firstOrderToDiscontinue, discontinuationOrder1.getPreviousOrder());
		
		//Lets discontinue another order with reason being a string instead of concept
		Order secondOrderToDiscontinue = orderService.getOrder(5);
		assertEquals(patient, secondOrderToDiscontinue.getPatient());
		assertTrue(OrderUtilTest.isActiveOrder(secondOrderToDiscontinue, null));
		Order discontinuationOrder2 = orderService.discontinueOrder(secondOrderToDiscontinue, "Testing", null, orderer,
		    encounter);
		assertEquals(secondOrderToDiscontinue, discontinuationOrder2.getPreviousOrder());
		
		//Lets discontinue another order by saving a DC order
		Order thirdOrderToDiscontinue = orderService.getOrder(7);
		assertTrue(OrderUtilTest.isActiveOrder(thirdOrderToDiscontinue, null));
		Order discontinuationOrder = thirdOrderToDiscontinue.cloneForDiscontinuing();
		discontinuationOrder.setOrderer(orderer);
		discontinuationOrder.setEncounter(encounterService.getEncounter(6));
		orderService.saveOrder(discontinuationOrder, null);
		
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(ordersCount - 3, activeOrders.size());
		assertFalse(activeOrders.contains(firstOrderToDiscontinue));
		assertFalse(activeOrders.contains(secondOrderToDiscontinue));
		assertFalse(activeOrders.contains(thirdOrderToDiscontinue));
	}
	
	@Test
	public void shouldReviseAnOrder() throws Exception {
		Order originalOrder = orderService.getOrder(111);
		assertTrue(OrderUtilTest.isActiveOrder(originalOrder, null));
		final Patient patient = originalOrder.getPatient();
		List<Order> originalActiveOrders = orderService.getActiveOrders(patient, null, null, null);
		final int originalOrderCount = originalActiveOrders.size();
		assertTrue(originalActiveOrders.contains(originalOrder));
		
		Order revisedOrder = originalOrder.cloneForRevision();
		revisedOrder.setInstructions("Take after a meal");
		revisedOrder.setDateActivated(new Date());
		revisedOrder.setOrderer(providerService.getProvider(1));
		revisedOrder.setEncounter(encounterService.getEncounter(3));
		orderService.saveOrder(revisedOrder, null);
		
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(originalOrderCount, activeOrders.size());
		assertEquals(revisedOrder.getDateActivated(), DateUtils.addSeconds(originalOrder.getDateStopped(), 1));
		assertFalse(OrderUtilTest.isActiveOrder(originalOrder, null));
	}
	
	/**
	 * @verifies void an order
	 * @see OrderService#voidOrder(org.openmrs.Order, String)
	 */
	@Test
	public void shouldVoidAnOrderAndFlushSuccessfully() throws Exception {
		Order order = orderService.getOrder(1);
		assertFalse(order.getVoided());
		assertNull(order.getDateVoided());
		assertNull(order.getVoidedBy());
		assertNull(order.getVoidReason());
		
		orderService.voidOrder(order, "None");
		//forces hibernate interceptors to get invoked
		Context.flushSession();
		assertTrue(order.getVoided());
		assertNotNull(order.getDateVoided());
		assertNotNull(order.getVoidedBy());
		assertNotNull(order.getVoidReason());
	}
	
	/**
	 * @verifies unvoid an order
	 * @see OrderService#unvoidOrder(org.openmrs.Order)
	 */
	@Test
	public void shouldUnvoidAnOrderAndFlushSuccessfully() throws Exception {
		Order order = orderService.getOrder(8);
		assertTrue(order.getVoided());
		assertNotNull(order.getDateVoided());
		assertNotNull(order.getVoidedBy());
		assertNotNull(order.getVoidReason());
		
		orderService.unvoidOrder(order);
		Context.flushSession();
		assertFalse(order.getVoided());
		assertNull(order.getDateVoided());
		assertNull(order.getVoidedBy());
		assertNull(order.getVoidReason());
	}
	
	@Test
	public void shouldDiscontinueAnActiveOrderAndFlushSuccessfully() throws Exception {
		executeDataSet(ORDER_ENTRY_DATASET_XML);
		executeDataSet("org/openmrs/api/include/OrderServiceTest-discontinueReason.xml");
		
		Order firstOrderToDiscontinue = orderService.getOrder(3);
		Encounter encounter = encounterService.getEncounter(3);
		assertTrue(OrderUtilTest.isActiveOrder(firstOrderToDiscontinue, null));
		
		Concept discontinueReason = Context.getConceptService().getConcept(1);
		Provider orderer = providerService.getProvider(1);
		Order discontinuationOrder1 = orderService.discontinueOrder(firstOrderToDiscontinue, discontinueReason, null,
		    orderer, encounter);
		Context.flushSession();
		assertEquals(firstOrderToDiscontinue, discontinuationOrder1.getPreviousOrder());
	}
	
	@Test
	public void shouldReviseAnOrderAndFlushSuccessfully() throws Exception {
		Order originalOrder = orderService.getOrder(111);
		assertTrue(OrderUtilTest.isActiveOrder(originalOrder, null));
		final Patient patient = originalOrder.getPatient();
		List<Order> originalActiveOrders = orderService.getActiveOrders(patient, null, null, null);
		final int originalOrderCount = originalActiveOrders.size();
		assertTrue(originalActiveOrders.contains(originalOrder));
		
		Order revisedOrder = originalOrder.cloneForRevision();
		revisedOrder.setInstructions("Take after a meal");
		revisedOrder.setDateActivated(new Date());
		revisedOrder.setOrderer(providerService.getProvider(1));
		revisedOrder.setEncounter(encounterService.getEncounter(3));
		orderService.saveOrder(revisedOrder, null);
		Context.flushSession();
		
		List<Order> activeOrders = orderService.getActiveOrders(patient, null, null, null);
		assertEquals(originalOrderCount, activeOrders.size());
		assertFalse(OrderUtilTest.isActiveOrder(originalOrder, null));
	}
	
	@Test
	public void shouldFailIfAnEditedOrderIsFlushed() throws Exception {
		Encounter encounter = encounterService.getEncounter(3);
		assertFalse(encounter.getOrders().isEmpty());
		encounter.getOrders().iterator().next().setInstructions("new");
		expectedException.expect(APIException.class);
		expectedException.expectMessage(Matchers.is("editing.fields.not.allowed"));
		encounterService.saveEncounter(encounter);
		Context.flushSession();
	}
	
	/**
	 * This test ensures that the getter for previous order field returns objects of the actual sub
	 * types for subclasses instead proxies that are instances of Order
	 * 
	 * @throws Exception
	 */
	@Test
	public void shouldNotReturnAProxyForPreviousOrder() throws Exception {
		Order dcOrder = orderService.getOrder(22);
		Order previousOrder = dcOrder.getPreviousOrder();
		assertNotNull(previousOrder);
		DrugOrder previousDrugOrder = (DrugOrder) previousOrder;
		
		Order testOrder = orderService.getOrder(7);
		Order dcTestOrder = orderService.discontinueOrder(testOrder, "Testing", null, testOrder.getOrderer(), testOrder
		        .getEncounter());
		Context.flushSession();
		Context.clearSession();
		dcTestOrder = (TestOrder) orderService.getOrder(dcTestOrder.getOrderId()).getPreviousOrder();
	}
	
	@Test
	public void shouldAllowEditingADiscontinuationOrder() throws Exception {
		Order originalDCOrder = orderService.getOrder(22);
		assertEquals(Order.Action.DISCONTINUE, originalDCOrder.getAction());
		List<Order> originalPatientOrders = orderService.getAllOrdersByPatient(originalDCOrder.getPatient());
		final Order previousOrder = originalDCOrder.getPreviousOrder();
		assertNotNull(previousOrder);
		final Date newStartDate = originalDCOrder.getEncounter().getEncounterDatetime();
		
		Order newDcOrder = originalDCOrder.cloneForRevision();
		newDcOrder.setEncounter(originalDCOrder.getEncounter());
		newDcOrder.setOrderer(originalDCOrder.getOrderer());
		newDcOrder.setDateActivated(newStartDate);
		orderService.voidOrder(originalDCOrder, "To be replace with a new one");
		assertNull(originalDCOrder.getDateStopped());
		orderService.saveOrder(newDcOrder, null);
		
		//We need to flush so that we ensure the interceptor is okay with all this
		Context.flushSession();
		assertTrue(originalDCOrder.isVoided());
		List<Order> newPatientOrders = orderService.getAllOrdersByPatient(originalDCOrder.getPatient());
		assertEquals(originalPatientOrders.size() + 1, newPatientOrders.size());
		Collection<Order> newOrders = CollectionUtils.disjunction(originalPatientOrders, newPatientOrders);
		assertEquals(1, newOrders.size());
		assertEquals(newOrders.iterator().next().getPreviousOrder(), previousOrder);
	}
	
	@Test
	public void shouldAllowRetrospectiveDataEntryOfOrders() throws Exception {
		Order order = new TestOrder();
		order.setPatient(patientService.getPatient(2));
		order.setCareSetting(orderService.getCareSetting(2));
		order.setConcept(conceptService.getConcept(5089));
		order.setEncounter(encounterService.getEncounter(6));
		order.setOrderer(providerService.getProvider(1));
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DAY_OF_WEEK, -1);
		order.setDateActivated(cal.getTime());
		orderService.saveOrder(order, null);
		
		cal.add(Calendar.HOUR_OF_DAY, -1);
		Date stopDate = cal.getTime();
		Order dcOrder = orderService.discontinueOrder(order, "Testing", stopDate, order.getOrderer(), order.getEncounter());
		assertEquals(stopDate, order.getDateStopped());
		assertEquals(stopDate, dcOrder.getAutoExpireDate());
	}
}

{'fraction_non_alphanumeric': 0.10163316970763484, 'fraction_numerical': 0.007008119539378222, 'mean_word_length': 5.651334702258727, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 27, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 6}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '3520469', 'n_tokens_mistral': 10063, 'n_tokens_neox': 9184, 'n_words': 1691}