@Override protected Provider getExistingObject() { return providerService.getProvider(EXISTING_ID); }
/** * @see ProviderService#isProviderIdentifierUnique(Provider) */ @Test public void isProviderIdentifierUnique_shouldReturnFalseIfTheIdentifierIsADuplicate() { executeDataSet(OTHERS_PROVIDERS_XML); Provider duplicateProvider = service.getProvider(200); Provider existingProviderToEdit = service.getProvider(1); existingProviderToEdit.setIdentifier(duplicateProvider.getIdentifier()); Assert.assertFalse(service.isProviderIdentifierUnique(existingProviderToEdit)); }
/** * @see ProviderService#getProvider(Integer) */ @Test public void getProvider_shouldGetProviderGivenID() { Provider provider = service.getProvider(2); assertEquals("Mr. Horatio Test Hornblower", provider.getName()); }
/** * @see OrderService#getDiscontinuationOrder(Order) */ @Test public void getDiscontinuationOrder_shouldReturnDiscontinuationOrderIfOrderHasBeenDiscontinued() { Order order = orderService.getOrder(111); Order discontinuationOrder = orderService.discontinueOrder(order, "no reason", new Date(), providerService.getProvider(1), order.getEncounter()); Order foundDiscontinuationOrder = orderService.getDiscontinuationOrder(order); assertThat(foundDiscontinuationOrder, is(discontinuationOrder)); }
/** * @see ProviderValidator#validate(Object, Errors) */ @Test public void validate_shouldAcceptDuplicateIdentifierIfTheExistingProviderIsNotRetired() { executeDataSet(OTHERS_PROVIDERS_XML); Provider duplicateProvider = providerService.getProvider(200); Provider existingProviderToEdit = providerService.getProvider(1); existingProviderToEdit.setIdentifier(duplicateProvider.getIdentifier()); providerValidator.validate(existingProviderToEdit, errors); Assert.assertFalse(errors.hasErrors()); }
/** * @see OrderService#getDiscontinuationOrder(Order) */ @Test public void getDiscontinuationOrder_shouldReturnNullIfDcOrderIsVoided() { Order order = orderService.getOrder(7); Order discontinueOrder = orderService.discontinueOrder(order, "Some reason", new Date(), providerService.getProvider(1), encounterService.getEncounter(3)); orderService.voidOrder(discontinueOrder, "Invalid reason"); Order discontinuationOrder = orderService.getDiscontinuationOrder(order); assertThat(discontinuationOrder, is(nullValue())); }
/** * @see ProviderService#purgeProvider(Provider) */ @Test public void purgeProvider_shouldDeleteAProvider() { Provider provider = service.getProvider(2); service.purgeProvider(provider); assertEquals(8, Context.getProviderService().getAllProviders().size()); }
/** * @see ProviderValidator#validate(Object, Errors) */ @Test public void validate_shouldAcceptDuplicateIdentifierIfTheExistingProviderIsRetired() { executeDataSet(OTHERS_PROVIDERS_XML); Provider duplicateRetiredProvider = providerService.getProvider(201); Assert.assertTrue(duplicateRetiredProvider.getRetired()); Provider provider = providerService.getProvider(1); provider.setIdentifier(duplicateRetiredProvider.getIdentifier()); providerValidator.validate(provider, errors); Assert.assertFalse(errors.hasErrors()); }
/** * @see ProviderValidator#validate(Object, Errors) */ @Test public void validate_shouldAcceptADuplicateIdentifierForANewProviderWhichIsRetired() { executeDataSet(OTHERS_PROVIDERS_XML); Provider duplicateProvider = providerService.getProvider(1); Assert.assertFalse(duplicateProvider.getRetired()); Provider providerToValidate = providerService.getProvider(201); Assert.assertTrue(providerToValidate.getRetired()); providerToValidate.setIdentifier(duplicateProvider.getIdentifier()); providerValidator.validate(providerToValidate, errors); Assert.assertFalse(errors.hasErrors()); }
/** * @see ProviderService#unretireProvider(Provider) */ @Test public void unretireProvider_shouldUnretireAProvider() { Provider provider = service.getProvider(2); service.unretireProvider(provider); assertFalse(provider.getRetired()); assertNull(provider.getRetireReason()); }
@Test public void saveOrder_shouldNotRevisePreviousIfAlreadyStopped() throws ParseException { executeDataSet("org/openmrs/api/include/OrderServiceTest-ordersWithAutoExpireDate.xml"); Order previousOrder = orderService.getOrder(203); Date dateActivated = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").parse("2008-10-19 13:00:00"); Order order = previousOrder.cloneForRevision(); order.setDateActivated(dateActivated); order.setOrderer(providerService.getProvider(1)); order.setEncounter(encounterService.getEncounter(18)); order.setPreviousOrder(previousOrder); expectedException.expect(CannotStopInactiveOrderException.class); expectedException.expectMessage(mss.getMessage("Order.cannot.discontinue.inactive")); orderService.saveRetrospectiveOrder(order, null); }
/** * @see ProviderService#retireProvider(Provider,String) */ @Test public void retireProvider_shouldRetireAProvider() { Provider provider = service.getProvider(1); assertFalse(provider.getRetired()); assertNull(provider.getRetireReason()); service.retireProvider(provider, "retire reason"); assertTrue(provider.getRetired()); assertEquals("retire reason", provider.getRetireReason()); assertEquals(6, service.getAllProviders(false).size()); }
/** * @see ProviderValidator#validate(Object, Errors) */ @Test public void validate_shouldAcceptADuplicateIdentifierForANewProviderWhichIsNotRetired() { Provider duplicateProvider = providerService.getProvider(1); Assert.assertFalse(duplicateProvider.getRetired()); Provider provider = new Provider(); provider.setIdentifier(duplicateProvider.getIdentifier()); providerValidator.validate(provider, errors); Assert.assertFalse(errors.hasFieldErrors("identifier")); }
/** * @see OrderService#saveOrder(org.openmrs.Order, OrderContext) */ @Test public void saveOrder_shouldSetOrderTypeIfNullButMappedToTheConceptClass() { TestOrder order = new TestOrder(); order.setPatient(patientService.getPatient(7)); order.setConcept(conceptService.getConcept(5497)); order.setOrderer(providerService.getProvider(1)); order.setCareSetting(orderService.getCareSetting(1)); order.setEncounter(encounterService.getEncounter(3)); order.setDateActivated(new Date()); orderService.saveOrder(order, null); assertEquals(2, order.getOrderType().getOrderTypeId().intValue()); }
@Test public void saveOrder_shouldFailDiscontinueNonCodedDrugOrderIfOrderableOfPreviousAndNewOrderDontMatch() { executeDataSet("org/openmrs/api/include/OrderServiceTest-nonCodedDrugs.xml"); DrugOrder previousOrder = (DrugOrder) orderService.getOrder(584); DrugOrder drugOrder = previousOrder.cloneForDiscontinuing(); drugOrder.setDrugNonCoded("non coded drug citrigine"); drugOrder.setPreviousOrder(previousOrder); drugOrder.setDateActivated(new Date()); drugOrder.setOrderer(providerService.getProvider(1)); drugOrder.setEncounter(encounterService.getEncounter(6)); expectedException.expect(EditedOrderDoesNotMatchPreviousException.class); expectedException.expectMessage("The orderable of the previous order and the new one order don't match"); orderService.saveOrder(drugOrder, null); }
private Encounter buildEncounter() { // First, create a new Encounter Encounter enc = new Encounter(); enc.setLocation(Context.getLocationService().getLocation(1)); enc.setEncounterType(Context.getEncounterService().getEncounterType(1)); enc.setEncounterDatetime(new Date()); enc.setPatient(Context.getPatientService().getPatient(3)); enc.addProvider(Context.getEncounterService().getEncounterRole(1), Context.getProviderService().getProvider(1)); return enc; }
@Test public void shouldDiscontinueAnActiveOrderAndFlushSuccessfully() { 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()); }
/** * @see OrderService#saveOrder(org.openmrs.Order, OrderContext) */ @Test public void saveOrder_shouldPassForADiscontinuationOrderWithNoPreviousOrder() { TestOrder dcOrder = new TestOrder(); dcOrder.setAction(Action.DISCONTINUE); dcOrder.setPatient(patientService.getPatient(2)); dcOrder.setCareSetting(orderService.getCareSetting(2)); dcOrder.setConcept(conceptService.getConcept(5089)); dcOrder.setEncounter(encounterService.getEncounter(6)); dcOrder.setOrderer(providerService.getProvider(1)); orderService.saveOrder(dcOrder, null); }
/** * @see OrderValidator#validate(Object,Errors) */ @Test public void validate_shouldFailValidationIfOrderAndEncounterHaveDifferentPatients() { Order order = new Order(); order.setConcept(Context.getConceptService().getConcept(88)); order.setPatient(Context.getPatientService().getPatient(2)); order.setEncounter(Context.getEncounterService().getEncounter(3)); order.setOrderer(Context.getProviderService().getProvider(1)); Errors errors = new BindException(order, "order"); new OrderValidator().validate(order, errors); Assert.assertTrue(errors.hasFieldErrors("encounter")); }
/** * @see OrderValidator#validate(Object, org.springframework.validation.Errors) */ @Test public void validate_shouldPassValidationIfTheClassOfTheOrderIsASubclassOfOrderTypejavaClass() { SomeDrugOrder order = new SomeDrugOrder(); order.setConcept(Context.getConceptService().getConcept(88)); order.setPatient(Context.getPatientService().getPatient(2)); order.setOrderer(Context.getProviderService().getProvider(1)); order.setOrderType(Context.getOrderService().getOrderTypeByName("Drug order")); Errors errors = new BindException(order, "order"); new OrderValidator().validate(order, errors); Assert.assertFalse(errors.hasFieldErrors("orderType")); }