method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
EncounterTransactionMapper { public EncounterTransaction map(Encounter encounter, Boolean includeAll) { Visit visit = encounter.getVisit(); EncounterTransaction encounterTransaction = new EncounterTransaction(visit.getUuid(), encounter.getUuid()); encounterTransaction.setPatientUuid(encounter.getPatient().getUuid()); encounterTransaction.setEncounterTypeUuid(encounter.getEncounterType() != null ? encounter.getEncounterType().getUuid() : null); encounterTransaction.setLocationUuid(encounter.getLocation() != null ? encounter.getLocation().getUuid() : null); encounterTransaction.setLocationName(encounter.getLocation() != null ? encounter.getLocation().getName() : null); encounterTransaction.setVisitTypeUuid(visit.getVisitType().getUuid()); encounterTransaction.setVisitLocationUuid(visit.getLocation() != null ? visit.getLocation().getUuid() : null); encounterTransaction.setEncounterDateTime(encounter.getEncounterDatetime()); encounterProviderMapper.update(encounterTransaction, encounter.getEncounterProviders()); encounterObservationsMapper.update(encounterTransaction, getSortedTopLevelObservations(encounter, includeAll)); if (orderMapper != null) { encounterTransaction.setDrugOrders(orderMapper.mapDrugOrders(encounter)); encounterTransaction.setOrders(orderMapper.mapOrders(encounter)); } postProcessEncounter(encounter,encounterTransaction); return encounterTransaction; } @Autowired(required = false) EncounterTransactionMapper(EncounterObservationsMapper encounterObservationsMapper, EncounterProviderMapper encounterProviderMapper); @Autowired(required = false) EncounterTransactionMapper(EncounterObservationsMapper encounterObservationsMapper, EncounterProviderMapper encounterProviderMapper, OrderMapper orderMapper); EncounterTransaction map(Encounter encounter, Boolean includeAll); }### Answer:
@Test public void shouldMap() throws Exception { Encounter encounter = new EncounterBuilder().build(); boolean includeAll = false; when(Context.getRegisteredComponents(EncounterTransactionHandler.class)).thenReturn(null); EncounterTransaction encounterTransaction = encounterTransactionMapper.map(encounter, includeAll); Assert.assertEquals(encounter.getUuid(), encounterTransaction.getEncounterUuid()); Assert.assertEquals(encounter.getVisit().getUuid(), encounterTransaction.getVisitUuid()); Assert.assertEquals(encounter.getPatient().getUuid(), encounterTransaction.getPatientUuid()); Assert.assertEquals(encounter.getEncounterType().getUuid(), encounterTransaction.getEncounterTypeUuid()); Assert.assertEquals(encounter.getLocation().getUuid(), encounterTransaction.getLocationUuid()); Assert.assertEquals(encounter.getLocation().getName(), encounterTransaction.getLocationName()); Assert.assertEquals(encounter.getVisit().getLocation().getUuid(), encounterTransaction.getVisitLocationUuid()); Assert.assertEquals(encounter.getVisit().getVisitType().getUuid(), encounterTransaction.getVisitTypeUuid()); }
@Test public void shouldMapEncounterWithoutEncounterType() throws Exception { Encounter encounter = new EncounterBuilder().withEncounterType(null).build(); when(Context.getRegisteredComponents(EncounterTransactionHandler.class)).thenReturn(null); EncounterTransaction encounterTransaction = encounterTransactionMapper.map(encounter, false); Assert.assertEquals(null, encounterTransaction.getEncounterTypeUuid()); }
@Test public void shouldMapEncounterTransactionsWithExtensions(){ Encounter encounter = new EncounterBuilder().build(); boolean includeAll = false; EncounterTransactionHandler encounterTransactionHandler = mock(EncounterTransactionHandler.class); when(Context.getRegisteredComponents(EncounterTransactionHandler.class)).thenReturn( Arrays.asList(encounterTransactionHandler)); encounterTransactionMapper = new EncounterTransactionMapper(encounterObservationsMapper, encounterProviderMapper, orderMapper); EncounterTransaction encounterTransaction = encounterTransactionMapper.map(encounter, includeAll); verify(encounterTransactionHandler).forRead(eq(encounter), any(EncounterTransaction.class)); }
|
### Question:
ObsMapper { public Obs transformEtObs(Encounter encounter,Obs observation, EncounterTransaction.Observation observationData) { if (observation == null) { observation = newObservation(encounter,observationData); } mapObservationProperties(observationData, observation); for (EncounterTransaction.Observation member : observationData.getGroupMembers()) { Obs nextLevelObs = getMatchingObservation(observation.getGroupMembers(), member.getUuid()); observation.addGroupMember(transformEtObs(encounter,nextLevelObs, member)); } return observation; } @Autowired ObsMapper(ConceptService conceptService,
EmrApiProperties emrApiProperties,
ObsService obsService, OrderService orderService); Obs transformEtObs(Encounter encounter,Obs observation, EncounterTransaction.Observation observationData); Obs getMatchingObservation(Set<Obs> existingObservations, String observationUuid); }### Answer:
@Test public void shouldTransformGivenETObsToObs() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid"); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); EncounterTransaction.Observation etObs = new EncounterTransaction.Observation().setUuid("o-uuid").setValue(35.0).setComment("overweight").setObservationDateTime(observationDateTime).setConcept(newEtConcept("ET_CONCEPT")); when(conceptService.getConceptByUuid(etObs.getConceptUuid())).thenReturn(numericConcept); Obs obs = this.obsMapper.transformEtObs(encounter,null, etObs); assertEquals(new Double(35.0), obs.getValueNumeric()); assertEquals("overweight", obs.getComment()); assertEquals(observationDateTime, obs.getObsDatetime()); assertEquals(patient, obs.getPerson()); }
@Test public void shouldVoidObs() throws ParseException { Concept numericConcept = newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid"); Date observationDateTime = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ").parse("2005-01-01T00:00:00.000+0000"); EncounterTransaction.Observation etObs = new EncounterTransaction.Observation().setUuid("o-uuid").setVoided(true).setValue("").setComment("overweight").setObservationDateTime(observationDateTime).setConcept(newEtConcept("ET_CONCEPT")); when(conceptService.getConceptByUuid(etObs.getConceptUuid())).thenReturn(numericConcept); Obs obs = this.obsMapper.transformEtObs(encounter,null, etObs); assertEquals(true, obs.getVoided()); assertEquals(patient, obs.getPerson()); }
|
### Question:
ObservationMapper1_12 extends ObservationMapper { @Override public EncounterTransaction.Observation map(Obs obs) { EncounterTransaction.Observation observation = super.map(obs); observation.setFormNamespace(obs.getFormFieldNamespace()); observation.setFormFieldPath(obs.getFormFieldPath()); setInterpretationAndStatus(observation, obs); return observation; } @Autowired ObservationMapper1_12(ConceptMapper conceptMapper, DrugMapper drugMapper, UserMapper userMapper); @Override EncounterTransaction.Observation map(Obs obs); }### Answer:
@Test public void shouldMapObservationWithNumericValue(){ when(conceptDatatype.isNumeric()).thenReturn(true); Obs obs = obsBuilder.setFormField("form uuid", "formFieldPath").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals(observation.getFormNamespace(), "form uuid"); assertEquals(observation.getFormFieldPath(), "formFieldPath"); }
|
### Question:
ObsMapper { public Obs getMatchingObservation(Set<Obs> existingObservations, String observationUuid) { if (existingObservations == null) return null; for (Obs obs : existingObservations) { if (StringUtils.equals(obs.getUuid(), observationUuid)) return obs; } return null; } @Autowired ObsMapper(ConceptService conceptService,
EmrApiProperties emrApiProperties,
ObsService obsService, OrderService orderService); Obs transformEtObs(Encounter encounter,Obs observation, EncounterTransaction.Observation observationData); Obs getMatchingObservation(Set<Obs> existingObservations, String observationUuid); }### Answer:
@Test public void shouldReturnMatchingObs() { Obs obs1 = new Obs(); obs1.setUuid("o1_uuid"); obs1.setConcept(newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid")); Obs obs2 = new Obs(); obs2.setUuid("o2_uuid"); obs2.setConcept(newConcept(new ConceptDataTypeBuilder().numeric(), "numeric-concept-uuid")); Set<Obs> obsSet = Sets.newSet(obs1, obs2); Obs obs = this.obsMapper.getMatchingObservation(obsSet, "o2_uuid"); assertEquals(obs2, obs); }
|
### Question:
ObservationMapper { public EncounterTransaction.Observation map(Obs obs) { Concept concept = obs.getConcept(); Object value = getValue(obs, concept); EncounterTransaction.Observation observation = new EncounterTransaction.Observation(); observation.setUuid(obs.getUuid()); observation.setConcept(conceptMapper.map(concept)); observation.setValue(value); observation.setVoided(obs.getVoided()); observation.setVoidReason(obs.getVoidReason()); observation.setObservationDateTime(obs.getObsDatetime()); observation.setComment(obs.getComment()); observation.setCreator(userMapper.map(obs.getCreator())); if (obs.getOrder() != null) { observation.setOrderUuid(obs.getOrder().getUuid()); } if (obs.getGroupMembers() != null) { for (Obs obsGroupMember : obs.getGroupMembers()) { observation.addGroupMember(map(obsGroupMember)); } } return observation; } @Autowired(required = false) ObservationMapper(ConceptMapper conceptMapper, DrugMapper drugMapper, UserMapper userMapper); EncounterTransaction.Observation map(Obs obs); }### Answer:
@Test public void shouldMapVoidedObservation(){ when(conceptDatatype.isNumeric()).thenReturn(true); Obs obs = obsBuilder.setVoided(true).setVoidedReason("reason").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals(obs.getUuid(), observation.getUuid()); assertEquals(obs.getVoided(), observation.getVoided()); assertEquals(obs.getVoidReason(), observation.getVoidReason()); }
@Test public void shouldMapConceptClassAndComment(){ when(conceptDatatype.isNumeric()).thenReturn(true); Obs obs = obsBuilder.setComment("Intermittent Pain").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals(obs.getComment(), observation.getComment()); assertEquals(obs.getConcept().getConceptClass().getName(), observation.getConcept().getConceptClass()); }
@Test public void shouldMapCreator() { when(conceptDatatype.isDate()).thenReturn(true); Obs obs = obsBuilder.setValue("2015-02-01").get(); EncounterTransaction.Observation observation = observationMapper.map(obs); assertEquals("uuid", observation.getCreator().getUuid()); assertEquals("superman", observation.getCreator().getPersonName()); }
|
### Question:
EncounterObservationsMapper { public void update(EncounterTransaction encounterTransaction, Set<Obs> allObs) { for (Obs obs : allObs) { ObservationTypeMatcher.ObservationType observationType = observationTypeMatcher.getObservationType(obs); switch (observationType) { case DIAGNOSIS: if (!obs.isVoided()) { encounterTransaction.addDiagnosis(diagnosisMapper.map(obs, getDiagnosisMetadata())); } break; case DISPOSITION: encounterTransaction.setDisposition(dispositionMapper.getDisposition(obs)); break; default: encounterTransaction.addObservation(observationMapper.map(obs)); break; } } } EncounterObservationsMapper(ObservationMapper observationMapper, DiagnosisMapper diagnosisMapper, DispositionMapper dispositionMapper, EmrApiProperties emrApiProperties, ObservationTypeMatcher observationTypeMatcher); void update(EncounterTransaction encounterTransaction, Set<Obs> allObs); }### Answer:
@Test public void testUpdateMapsDiagnosis() throws Exception { EncounterTransaction encounterTransaction = new EncounterTransaction(); Obs obs1 = new Obs(); Obs obs2 = new Obs(); Obs obs3 = new Obs(); Obs obs4 = new Obs(); HashSet<Obs> allObs = new HashSet<Obs>(Arrays.asList(obs1, obs2, obs3, obs4)); when(observationTypeMatcher.getObservationType(obs1)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); when(observationTypeMatcher.getObservationType(obs2)).thenReturn(ObservationTypeMatcher.ObservationType.OBSERVATION); when(observationTypeMatcher.getObservationType(obs3)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); EncounterTransaction.Disposition disposition = new EncounterTransaction.Disposition(); when(observationTypeMatcher.getObservationType(obs4)).thenReturn(ObservationTypeMatcher.ObservationType.DISPOSITION); when(dispositionMapper.getDisposition(obs4)).thenReturn(disposition); encounterObservationsMapper.update(encounterTransaction, allObs); assertEquals(2, encounterTransaction.getDiagnoses().size()); assertEquals(disposition, encounterTransaction.getDisposition()); assertEquals(1, encounterTransaction.getObservations().size()); }
@Test public void updateShouldNotMapVoidedDiagnosis() throws Exception { EncounterTransaction encounterTransaction = new EncounterTransaction(); Obs obs1 = new Obs(); Obs obs2 = new Obs(); obs2.setVoided(Boolean.TRUE); HashSet<Obs> allObs = new HashSet<Obs>(Arrays.asList(obs1, obs2)); when(observationTypeMatcher.getObservationType(obs1)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); when(observationTypeMatcher.getObservationType(obs2)).thenReturn(ObservationTypeMatcher.ObservationType.DIAGNOSIS); encounterObservationsMapper.update(encounterTransaction, allObs); assertEquals(1, encounterTransaction.getDiagnoses().size()); }
|
### Question:
OrderMapper1_12 implements OrderMapper { @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()); emrOrder.setUrgency(String.valueOf(order.getUrgency())); Order previousOrder = order.getPreviousOrder(); if (previousOrder != null && StringUtils.isNotBlank(previousOrder.getUuid())) { emrOrder.setPreviousOrderUuid(previousOrder.getUuid()); } return emrOrder; } @Override List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter); @Override List<EncounterTransaction.Order> mapOrders(Encounter encounter); @Override EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder); @Override EncounterTransaction.Order mapOrder(Order order); }### Answer:
@Test public void shouldMapNewOrder() throws ParseException, NoSuchFieldException, IllegalAccessException { Order openMrsOrder = order("boil in water", "comments", "ORD-99", "ORD-100", ORDER_TYPE,"STAT"); openMrsOrder.setUuid(ORDER_UUID); EncounterTransaction.Order order = orderMapper1_12.mapOrder(openMrsOrder); assertThat(order.getAction(), is(equalTo(Order.Action.NEW.name()))); assertThat(order.getUuid(), is(equalTo(ORDER_UUID))); assertThat(order.getOrderType(), is(equalTo(ORDER_TYPE))); assertThat(order.getInstructions(), is(equalTo("boil in water"))); assertThat(order.getCommentToFulfiller(), is(equalTo("comments"))); assertThat(order.getUrgency(),is(equalTo("STAT"))); assertThat(order.getOrderNumber(), is(equalTo("ORD-100"))); assertThat(order.getDateCreated(), is(equalTo(new LocalDate().toDate()))); assertThat(order.getDateChanged(), is(equalTo(new LocalDate().toDate()))); assertThat(order.getOrderNumber(), is(equalTo("ORD-100"))); }
@Test public void shouldSetPreviousOrder() throws NoSuchFieldException, IllegalAccessException { Order openMrsOrder = order("boil in water", "comments", "Previous Order Uuid", "ORD-100", ORDER_TYPE,"ROUTINE"); EncounterTransaction.Order order = orderMapper1_12.mapOrder(openMrsOrder); assertThat(order.getPreviousOrderUuid(), is(equalTo("Previous Order Uuid"))); }
|
### Question:
DiagnosisMapper { public List<EncounterTransaction.Diagnosis> convert(List<Diagnosis> pastDiagnoses) { List<EncounterTransaction.Diagnosis> pastEncounterDiagnoses = new ArrayList<EncounterTransaction.Diagnosis>(); for (Diagnosis diagnosis : pastDiagnoses) { pastEncounterDiagnoses.add(convert(diagnosis)); } return pastEncounterDiagnoses; } EncounterTransaction.Diagnosis map(Obs obs, DiagnosisMetadata diagnosisMetadata); List<EncounterTransaction.Diagnosis> convert(List<Diagnosis> pastDiagnoses); EncounterTransaction.Diagnosis convert(Diagnosis diagnosis); }### Answer:
@Test public void shouldMapEmrapiDiagnosisToEncounterTransactionDiagnosis() throws Exception { DiagnosisMapper diagnosisMapper = new DiagnosisMapper(); Diagnosis diagnosis = new Diagnosis(); diagnosis.setCertainty(Diagnosis.Certainty.CONFIRMED); diagnosis.setOrder(Diagnosis.Order.PRIMARY); CodedOrFreeTextAnswer freeTextAnswer = new CodedOrFreeTextAnswer(); freeTextAnswer.setNonCodedAnswer("cold"); diagnosis.setDiagnosis(freeTextAnswer); Obs existingObs = new Obs(); existingObs.setEncounter(new Encounter()); existingObs.setComment("comment"); diagnosis.setExistingObs(existingObs); EncounterTransaction.Diagnosis etDiagnosis = diagnosisMapper.convert(diagnosis); assertEquals(Diagnosis.Certainty.CONFIRMED.toString(), etDiagnosis.getCertainty()); assertEquals(Diagnosis.Order.PRIMARY.toString(), etDiagnosis.getOrder()); assertEquals("cold", etDiagnosis.getFreeTextAnswer()); assertNull(etDiagnosis.getCodedAnswer()); assertEquals("comment", etDiagnosis.getComments()); }
|
### Question:
EncounterProviderMapper { public void update(EncounterTransaction encounterTransaction, Set<EncounterProvider> encounterProviders) { Set<EncounterTransaction.Provider> providers = convert(encounterProviders); encounterTransaction.setProviders(providers); } void update(EncounterTransaction encounterTransaction, Set<EncounterProvider> encounterProviders); Set<EncounterTransaction.Provider> convert(Set<EncounterProvider> encounterProviders); }### Answer:
@Test public void shouldMapProviders(){ EncounterTransaction encounterTransaction = new EncounterTransaction(); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); EncounterProvider encounterProvider = new EncounterProviderBuilder().build(); encounterProviders.add(encounterProvider); encounterProviderMapper.update(encounterTransaction,encounterProviders); Set<EncounterTransaction.Provider> mappedProviders = encounterTransaction.getProviders(); assertThat(mappedProviders.size(), is(1)); EncounterTransaction.Provider provider = mappedProviders.iterator().next(); assertThat(provider.getName(), is(equalTo(encounterProvider.getProvider().getName()))); assertThat(provider.getEncounterRoleUuid(), is(equalTo(encounterProvider.getEncounterRole().getUuid()))); }
@Test public void shouldMapProvidersWithoutEncounterRole(){ EncounterTransaction encounterTransaction = new EncounterTransaction(); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); EncounterProvider encounterProvider = new EncounterProviderBuilder().build(); encounterProvider.setEncounterRole(null); encounterProviders.add(encounterProvider); encounterProviderMapper.update(encounterTransaction,encounterProviders); Set<EncounterTransaction.Provider> mappedProviders = encounterTransaction.getProviders(); assertThat(mappedProviders.size(), is(1)); EncounterTransaction.Provider provider = mappedProviders.iterator().next(); assertThat(provider.getName(), is(equalTo(encounterProvider.getProvider().getName()))); assertThat(provider.getEncounterRoleUuid(), is(nullValue())); }
|
### Question:
EncounterDomainWrapper implements DomainWrapper { public boolean participatedInEncounter(User currentUser) { if (verifyIfUserIsTheCreatorOfEncounter(currentUser)) { return true; } else if (verifyIfUserIsOneOfTheProviders(currentUser)) { return true; } return false; } EncounterDomainWrapper(); @Deprecated // use DomainWrapperFactory EncounterDomainWrapper(Encounter encounter); Encounter getEncounter(); void setEncounter(Encounter encounter); Visit getVisit(); Location getLocation(); Date getEncounterDatetime(); int getEncounterId(); Form getForm(); Boolean getVoided(); Set<EncounterProvider> getEncounterProviders(); Provider getPrimaryProvider(); boolean participatedInEncounter(User currentUser); void closeVisit(); Map<EncounterRole, Set<Provider>> getProviders(); @Transactional void attachToVisit(VisitDomainWrapper visit); @Transactional void attachToVisit(Visit visit); static final Predicate NON_VOIDED_PREDICATE; static final Comparator<Encounter> DATETIME_COMPARATOR; }### Answer:
@Test public void shouldReturnTrueWhenTheCurrentUserCreatedTheEncounter(){ User currentUser = createUserWithUuid("585812f0-a860-11e2-9e96-0800200c9a66"); User encounterCreator = createUserWithUuid("585812f0-a860-11e2-9e96-0800200c9a66"); when(encounter.getCreator()).thenReturn(encounterCreator); assertTrue(encounterDomainWrapper.participatedInEncounter(currentUser)); }
|
### Question:
EncounterDomainWrapper implements DomainWrapper { @Transactional public void attachToVisit(VisitDomainWrapper visit) throws EncounterDateBeforeVisitStartDateException, EncounterDateAfterVisitStopDateException { if (dateHasTimeComponent(encounter.getEncounterDatetime())) { if (encounter.getEncounterDatetime().before(visit.getStartDatetime())) { throw new EncounterDateBeforeVisitStartDateException(); } if (visit.getStopDatetime() != null && encounter.getEncounterDatetime().after(visit.getStopDatetime())) { throw new EncounterDateAfterVisitStopDateException(); } } else { DateMidnight encounterDate = new DateMidnight(encounter.getEncounterDatetime()); DateMidnight currentDate = new DateMidnight(); DateMidnight visitStartDate = new DateMidnight(visit.getStartDatetime()); DateMidnight visitStopDate = visit.getStopDatetime() != null ? new DateMidnight(visit.getStopDatetime()) : null; if (encounterDate.isBefore(visitStartDate)) { throw new EncounterDateBeforeVisitStartDateException(); } if (visitStopDate != null && encounterDate.isAfter(visitStopDate)) { throw new EncounterDateAfterVisitStopDateException(); } if (encounterDate.equals(currentDate) && visit.isOpen()) { setEncounterDatetimeAndPropagateToObs(encounter, new Date()); } else if (encounterDate.isBefore(new DateTime(visit.getStartDatetime()))) { setEncounterDatetimeAndPropagateToObs(encounter, visit.getStartDatetime()); } } encounter.setVisit(visit.getVisit()); } EncounterDomainWrapper(); @Deprecated // use DomainWrapperFactory EncounterDomainWrapper(Encounter encounter); Encounter getEncounter(); void setEncounter(Encounter encounter); Visit getVisit(); Location getLocation(); Date getEncounterDatetime(); int getEncounterId(); Form getForm(); Boolean getVoided(); Set<EncounterProvider> getEncounterProviders(); Provider getPrimaryProvider(); boolean participatedInEncounter(User currentUser); void closeVisit(); Map<EncounterRole, Set<Provider>> getProviders(); @Transactional void attachToVisit(VisitDomainWrapper visit); @Transactional void attachToVisit(Visit visit); static final Predicate NON_VOIDED_PREDICATE; static final Comparator<Encounter> DATETIME_COMPARATOR; }### Answer:
@Test(expected = EncounterDateBeforeVisitStartDateException.class) public void test_attachToVisit_shouldFailIfEncounterDateBeforeVisitStartDate() throws Exception { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateMidnight(2012,12,12).toDate()); EncounterDomainWrapper encounterWrapper = new EncounterDomainWrapper(encounter); Visit visit = new Visit(); visit.setStartDatetime(new DateTime(2012, 12, 13, 10, 10, 10).toDate()); visit.setStopDatetime(new DateTime(2012, 12, 15, 10, 10, 10).toDate()); encounterWrapper.attachToVisit(visit); }
@Test(expected = EncounterDateAfterVisitStopDateException.class) public void test_attachToVisit_shouldFailIfEncounterDateAfterVisitStopDate() throws Exception { Encounter encounter = new Encounter(); encounter.setEncounterDatetime(new DateMidnight(2012,12,16).toDate()); EncounterDomainWrapper encounterWrapper = new EncounterDomainWrapper(encounter); Visit visit = new Visit(); visit.setStartDatetime(new DateTime(2012, 12, 13, 10, 10, 10).toDate()); visit.setStopDatetime(new DateTime(2012, 12, 15, 10, 10, 10).toDate()); encounterWrapper.attachToVisit(visit); }
|
### Question:
OrderMapper1_12 implements OrderMapper { @Override public List<EncounterTransaction.Order> mapOrders(Encounter encounter) { List<EncounterTransaction.Order> orders = new ArrayList<EncounterTransaction.Order>(); for (Order order : encounter.getOrders()) { order = HibernateUtil.getRealObjectFromProxy(order); if (Order.class.equals(order.getClass())) { orders.add(mapOrder(order)); } } return orders; } @Override List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter); @Override List<EncounterTransaction.Order> mapOrders(Encounter encounter); @Override EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder); @Override EncounterTransaction.Order mapOrder(Order order); }### Answer:
@Test public void shouldMapMultipleOrders() throws NoSuchFieldException, IllegalAccessException { Order order100 = order("before meals", "boil in water", null, "ORD-100", ORDER_TYPE, "ROUTINE"); Order order201 = order("before meals", "boil in water", null, "ORD-201", ORDER_TYPE, "ROUTINE"); Order order350 = order("before meals", "boil in water", null, "ORD-350", ORDER_TYPE, "ROUTINE"); Encounter encounter = new Encounter(); encounter.setOrders(new HashSet<Order>(Arrays.asList(order350, order100, order201))); List<EncounterTransaction.Order> ordersList = orderMapper1_12.mapOrders(encounter); assertEquals(3, ordersList.size()); }
|
### Question:
EncounterDomainWrapper implements DomainWrapper { public Provider getPrimaryProvider() { for (EncounterProvider provider : encounter.getEncounterProviders()) { if (!provider.isVoided()) { return provider.getProvider(); } } return null; } EncounterDomainWrapper(); @Deprecated // use DomainWrapperFactory EncounterDomainWrapper(Encounter encounter); Encounter getEncounter(); void setEncounter(Encounter encounter); Visit getVisit(); Location getLocation(); Date getEncounterDatetime(); int getEncounterId(); Form getForm(); Boolean getVoided(); Set<EncounterProvider> getEncounterProviders(); Provider getPrimaryProvider(); boolean participatedInEncounter(User currentUser); void closeVisit(); Map<EncounterRole, Set<Provider>> getProviders(); @Transactional void attachToVisit(VisitDomainWrapper visit); @Transactional void attachToVisit(Visit visit); static final Predicate NON_VOIDED_PREDICATE; static final Comparator<Encounter> DATETIME_COMPARATOR; }### Answer:
@Test public void test_getPrimaryProvider_shouldReturnFirstNonVoidedEncounterProvider() { Encounter encounter = new Encounter(); Provider provider1 = new Provider(); Provider provider2 = new Provider(); EncounterRole role = new EncounterRole(); EncounterProvider encounterProvider1 = new EncounterProvider(); encounterProvider1.setVoided(true); encounterProvider1.setProvider(provider1); encounterProvider1.setEncounterRole(role); EncounterProvider encounterProvider2 = new EncounterProvider(); encounterProvider2.setVoided(false); encounterProvider2.setProvider(provider2); encounterProvider2.setEncounterRole(role); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); encounterProviders.add(encounterProvider1); encounterProviders.add(encounterProvider2); encounter.setEncounterProviders(encounterProviders); assertThat(new EncounterDomainWrapper(encounter).getPrimaryProvider(), is(provider2)); }
@Test public void test_getPrimaryProvider_shouldReturnNullIfNoNonVoidedEncounterProviders() { Encounter encounter = new Encounter(); Provider provider1 = new Provider(); Provider provider2 = new Provider(); EncounterRole role = new EncounterRole(); EncounterProvider encounterProvider1 = new EncounterProvider(); encounterProvider1.setVoided(true); encounterProvider1.setProvider(provider1); encounterProvider1.setEncounterRole(role); EncounterProvider encounterProvider2 = new EncounterProvider(); encounterProvider2.setVoided(true); encounterProvider2.setProvider(provider2); encounterProvider2.setEncounterRole(role); Set<EncounterProvider> encounterProviders = new HashSet<EncounterProvider>(); encounterProviders.add(encounterProvider1); encounterProviders.add(encounterProvider2); encounter.setEncounterProviders(encounterProviders); assertNull(new EncounterDomainWrapper(encounter).getPrimaryProvider()); }
|
### Question:
EncounterTransaction { public Map<String, Object> getContext() { return context; } EncounterTransaction(); EncounterTransaction(String visitUuid, String encounterUuid); String getVisitLocationUuid(); void setVisitLocationUuid(String visitLocationUuid); Map<String, Object> getExtensions(); void setExtensions(Map<String, Object> extensions); Disposition getDisposition(); void setDisposition(Disposition disposition); String getPatientUuid(); String getEncounterTypeUuid(); String getVisitTypeUuid(); EncounterTransaction setPatientUuid(String patientUuid); EncounterTransaction setVisitTypeUuid(String visitTypeUuid); EncounterTransaction setEncounterTypeUuid(String encounterTypeUuid); EncounterTransaction setObservations(List<Observation> observations); String getLocationName(); EncounterTransaction setLocationName(String locationName); List<Observation> getObservations(); List<Order> getOrders(); void setOrders(List<Order> orders); List<DrugOrder> getDrugOrders(); void setDrugOrders(List<DrugOrder> drugOrders); @JsonSerialize(using = CustomJsonDateSerializer.class) Date getEncounterDateTime(); EncounterTransaction setEncounterDateTime(Date encounterDateTime); String getLocationUuid(); EncounterTransaction setLocationUuid(String locationUuid); List<Diagnosis> getDiagnoses(); void setDiagnoses(List<Diagnosis> diagnoses); String getVisitUuid(); void setVisitUuid(String visitUuid); String getEncounterUuid(); void setEncounterUuid(String encounterUuid); Map<String, Object> getContext(); void setContext(Map<String, Object> context); void addObservation(Observation observation); void addOrder(Order order); void addDrugOrder(DrugOrder drugOrder); void addDiagnosis(Diagnosis diagnosis); Set<Provider> getProviders(); void setProviders(Set<Provider> providers); }### Answer:
@Test public void shouldDeserializeContext() throws IOException { String patientProgramUuidKey = "patientProgramUuid"; String patientProgramUuidValue = "c4f735a8-dbac-11e5-b5d2-0a1d41d68578"; EncounterTransaction encounterTransaction = new ObjectMapper().readValue("{" + " \"context\": {" + " \"" + patientProgramUuidKey + "\": \"" + patientProgramUuidValue + "\"," + " \"anotherKey\": \"anotherValue\"," + " \"contextObject\": {" + " \"key\": \"value\"" + " }" + " }" + "}", EncounterTransaction.class); Map<String, Object> context = encounterTransaction.getContext(); assertThat(context.get(patientProgramUuidKey), is(equalTo((Object) patientProgramUuidValue))); }
|
### Question:
VisitDomainWrapper implements DomainWrapper { public Date getEncounterStopDateRange() { return getStopDatetime() == null ? new Date() : getStopDatetime(); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); }### Answer:
@Test public void shouldUseTheStopDateOfTheVisitForEncounterStopDateRange() { DateTime visitEndDate = new DateTime(2013, 1, 15, 12, 12, 12); Visit visit = new Visit(); visit.setStopDatetime(visitEndDate.toDate()); VisitDomainWrapper wrapper = new VisitDomainWrapper(visit); assertThat(wrapper.getEncounterStopDateRange(), is(visitEndDate.toDate())); }
@Test public void shouldReturnNowForStopDateRangeIfStopDateOfTheVisitIsNull() { Visit visit = new Visit(); visit.setStopDatetime(null); VisitDomainWrapper wrapper = new VisitDomainWrapper(visit); assertThat(wrapper.getEncounterStopDateRange(), within(1, SECONDS, new Date())); }
|
### Question:
VisitDomainWrapper implements DomainWrapper { public Encounter getMostRecentEncounter() { List<Encounter> encounters = getSortedEncounters(SortOrder.MOST_RECENT_FIRST); if (encounters.size() > 0) return encounters.get(0); return null; } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); }### Answer:
@Test public void shouldReturnNullOnMostRecentEncounterIfNoEncounters() throws Exception { assertThat(new VisitDomainWrapper(new Visit()).getMostRecentEncounter(), is(nullValue())); }
|
### Question:
VisitDomainWrapper implements DomainWrapper { public void closeOnLastEncounterDatetime() { Encounter mostRecentEncounter = getMostRecentEncounter(); if (mostRecentEncounter == null) { throw new IllegalStateException("Visit has no encounters"); } visit.setStopDatetime(mostRecentEncounter.getEncounterDatetime()); } VisitDomainWrapper(); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties); @Deprecated // use new VisitDomainWrapperFactory instead to instantiate a visit domain wrapper VisitDomainWrapper(Visit visit, EmrApiProperties emrApiProperties, DispositionService dispositionService); Visit getVisit(); void setVisit(Visit visit); int getVisitId(); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setDispositionService(DispositionService dispositionService); void setVisitQueryService(VisitQueryService visitQueryService); Encounter getAdmissionEncounter(); Encounter getLatestAdtEncounter(); boolean isActive(); @Deprecated // renamed to is Active boolean isOpen(); Encounter getMostRecentCheckInEncounter(); Encounter getEarliestCheckInEncounter(); @Deprecated // use getMostRecentCheckInEncounter, as this is a more accurate method name Encounter getCheckInEncounter(); Encounter getMostRecentEncounter(); @Deprecated //use getMostRecentEncounter because this method name doesn't make sense Encounter getLastEncounter(); Encounter getEarliestEncounter(); @Deprecated // we are standardizing on "Earliest" and "Most Recent" to the Encounter getOldestEncounter(); Encounter getMostRecentVisitNote(); Encounter getMostRecentVisitNoteAtLocation(Location location); boolean hasVisitNote(); boolean hasVisitNoteAtLocation(Location location); List<Encounter> getSortedEncounters(); List<Encounter> getSortedEncounters(SortOrder order); int getDifferenceInDaysBetweenCurrentDateAndStartDate(); Disposition getMostRecentDisposition(); List<Diagnosis> getDiagnosesFromMostRecentDispositionByType(DispositionType type); List<Diagnosis> getPrimaryDiagnoses(); List<Diagnosis> getUniqueDiagnoses(Boolean primaryOnly, Boolean confirmedOnly); @Deprecated List<Diagnosis> getUniqueDiagnosesLegacy(Boolean primaryOnly, Boolean confirmedOnly); boolean hasEncounters(); boolean hasEncounterWithoutSubsequentEncounter(EncounterType lookForEncounterType, EncounterType withoutSubsequentEncounterType); boolean isAdmitted(); boolean isAdmitted(Date onDate); boolean isAwaitingAdmission(); Location getInpatientLocation(Date onDate); Date getStartDatetime(); Date getStopDatetime(); Date getStartDate(); Date getStopDate(); VisitDomainWrapper addEncounter(Encounter encounter); void closeOnLastEncounterDatetime(); void errorIfOutsideVisit(Date checkDatetime, String errorMessage); Date getEncounterStopDateRange(); boolean verifyIfUserIsTheCreatorOfVisit(User currentUser); Object getVisitAttribute(String uuidOrName); }### Answer:
@Test(expected = IllegalStateException.class) public void shouldFailIfNoEncounters() throws Exception { Date startDate = new DateTime(2012,2,20,10,10).toDate(); Visit visit = new Visit(); visit.setStartDatetime(startDate); new VisitDomainWrapper(visit).closeOnLastEncounterDatetime(); }
|
### Question:
EmrVisitServiceImpl extends BaseOpenmrsService implements EmrVisitService { @Override public VisitResponse find(VisitRequest visitRequest) { Visit visit = visitService.getVisitByUuid(visitRequest.getVisitUuid()); if(visit == null) throw new VisitNotFoundException("Visit by uuid "+ visitRequest.getVisitUuid() + " does not exist"); return visitResponseMapper.map(visit); } EmrVisitServiceImpl(VisitService visitService, VisitResponseMapper visitResponseMapper); EmrVisitDAO getDao(); void setDao(EmrVisitDAO dao); @Override VisitResponse find(VisitRequest visitRequest); @Override List<Obs> getDiagnoses(Visit visit, DiagnosisMetadata diagnosisMetadata, Boolean primaryOnly, Boolean confirmedOnly); @Override List<Integer> getAllPatientsWithDiagnosis(DiagnosisMetadata diagnosisMetadata); }### Answer:
@Test public void shouldFindVisitByUuid() throws Exception { VisitRequest visitRequest = new VisitRequest(UUID.randomUUID().toString()); Visit visit = new Visit(); when(visitService.getVisitByUuid(visitRequest.getVisitUuid())).thenReturn(visit); VisitResponse visitResponse = new VisitResponse(visit.getUuid()); when(visitResponseMapper.map(visit)).thenReturn(visitResponse); VisitResponse visitResponseFromService = emrVisitService.find(visitRequest); assertEquals(visitResponse, visitResponseFromService); verify(visitService).getVisitByUuid(visitRequest.getVisitUuid()); }
@Test(expected = VisitNotFoundException.class) public void shouldRaiseExceptionForNonExistingVisit() throws Exception { VisitRequest visitRequest = new VisitRequest(UUID.randomUUID().toString()); when(visitService.getVisitByUuid(visitRequest.getVisitUuid())).thenReturn(null); emrVisitService.find(visitRequest); }
|
### Question:
VisitResponseMapper { public VisitResponse map(Visit visit) { if(visit == null) return null; VisitResponse visitResponse = new VisitResponse(visit.getUuid()); for (Encounter encounter : visit.getEncounters()) { visitResponse.addEncounter(encounterTransactionMapper.map(encounter, true)); } return visitResponse; } VisitResponseMapper(EncounterTransactionMapper encounterTransactionMapper); VisitResponse map(Visit visit); }### Answer:
@Test public void testMapsVisit() throws Exception { Visit visit = new Visit(); visit.addEncounter(new Encounter()); VisitResponse visitResponse = visitResponseMapper.map(visit); Assert.assertEquals(visit.getUuid(), visitResponse.getVisitUuid()); Assert.assertEquals(visit.getEncounters().size(), visitResponse.getEncounters().size()); }
@Test public void testMapsNullVisitToNull() throws Exception { Assert.assertNull(visitResponseMapper.map(null)); }
|
### Question:
OrderMetadataService { public Concept getDurationUnitsConceptByName(String conceptName) { List<Concept> durationUnits = orderService.getDurationUnits(); for (Concept durationUnit : durationUnits) { if(durationUnit.getName().getName().equals(conceptName)){ return durationUnit; } } return null; } @Autowired OrderMetadataService(OrderService orderService); Concept getDurationUnitsConceptByName(String conceptName); OrderFrequency getOrderFrequencyByName(String conceptName, boolean includeRetired); }### Answer:
@Test public void shouldGetDurationConceptByName() throws Exception { Concept days = createConcept(DAYS_CONCEPT_NAME); Concept weeks = createConcept(WEEKS_CONCEPT_NAME); when(orderService.getDurationUnits()).thenReturn(Arrays.asList(days, weeks)); Concept durationUnitsConcept = orderMetadataService.getDurationUnitsConceptByName(DAYS_CONCEPT_NAME); assertThat(durationUnitsConcept, is(days)); }
@Test public void shouldReturnNullIfDurationConceptDoesNotExist() throws Exception { when(orderService.getDurationUnits()).thenReturn(new ArrayList<Concept>()); Concept durationUnitsConcept = orderMetadataService.getDurationUnitsConceptByName(DAYS_CONCEPT_NAME); assertNull(durationUnitsConcept); }
@Test public void shouldReturnNullDurationUnitsForNullInput() { assertNull(orderMetadataService.getDurationUnitsConceptByName(null)); }
|
### Question:
OrderMapper1_12 implements OrderMapper { @Override public List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter) { List<EncounterTransaction.DrugOrder> orders = new ArrayList<EncounterTransaction.DrugOrder>(); for (Order order : encounter.getOrders()) { order = HibernateUtil.getRealObjectFromProxy(order); if (DrugOrder.class.equals(order.getClass())) { orders.add(mapDrugOrder((DrugOrder) order)); } } sortByOrderNumber(orders); return orders; } @Override List<EncounterTransaction.DrugOrder> mapDrugOrders(Encounter encounter); @Override List<EncounterTransaction.Order> mapOrders(Encounter encounter); @Override EncounterTransaction.DrugOrder mapDrugOrder(DrugOrder openMRSDrugOrder); @Override EncounterTransaction.Order mapOrder(Order order); }### Answer:
@Test public void shouldReturnDrugOrdersSortedByOrderNumber() throws NoSuchFieldException, IllegalAccessException { DrugOrder drugOrder100 = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-100"); DrugOrder drugOrder201 = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-201"); DrugOrder drugOrder350 = drugOrder(CareSetting.CareSettingType.OUTPATIENT, 3, "3-0-2", 5, "before meals", "boil in water", null, "ORD-350"); Encounter encounter = new Encounter(); encounter.setOrders(new HashSet<Order>(Arrays.asList(drugOrder350, drugOrder100, drugOrder201))); List<EncounterTransaction.DrugOrder> sortedDrugOrders = orderMapper1_12.mapDrugOrders(encounter); assertEquals("ORD-100", sortedDrugOrders.get(0).getOrderNumber()); assertEquals("ORD-201", sortedDrugOrders.get(1).getOrderNumber()); assertEquals("ORD-350", sortedDrugOrders.get(2).getOrderNumber()); }
|
### Question:
EmrPatientProfileServiceImpl implements EmrPatientProfileService { @Override public PatientProfile save(PatientProfile patientProfile) { Patient patient = patientService.savePatient(patientProfile.getPatient()); saveRelationships(patientProfile.getRelationships()); patientProfile.setPatient(patient); PersonImage personImage = new PersonImage(); personImage.setPerson(patient); personImage.setBase64EncodedImage(patientProfile.getImage()); emrPersonImageService.savePersonImage(personImage); return patientProfile; } @Override PatientProfile save(PatientProfile patientProfile); @Override PatientProfile get(String patientUuid); void setPatientService(PatientService patientService); void setPersonService(PersonService personService); void setEmrPersonImageService(EmrPersonImageService emrPersonImageService); }### Answer:
@Test public void shouldSavePatientProfile() throws Exception { PatientProfile patientProfile = emrPatientProfileService.save(constructPatientProfile()); assertNotNull(patientProfile); assertEquals(patientProfile.getRelationships().size(), 1); }
|
### Question:
ConditionHistoryMapper { public ConditionHistory map(org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory) { ConditionHistory conditionHistoryContract = new ConditionHistory(); conditionHistoryContract.setConceptUuid(conditionHistory.getCondition().getUuid()); ArrayList<Condition> conditions = new ArrayList<Condition>(); for (org.openmrs.module.emrapi.conditionslist.Condition condition : conditionHistory.getConditions()) { conditions.add(conditionMapper.map(condition)); } conditionHistoryContract.setConditions(conditions); conditionHistoryContract.setConditionNonCoded(conditionHistory.getNonCodedCondition()); return conditionHistoryContract; } ConditionHistoryMapper(ConditionMapper conditionMapper); ConditionHistory map(org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory); List<ConditionHistory> map(List<org.openmrs.module.emrapi.conditionslist.ConditionHistory> conditionHistories100); }### Answer:
@Test public void shouldMapConditionHistoryModalToContract() throws Exception { org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory = new org.openmrs.module.emrapi.conditionslist.ConditionHistory(); org.openmrs.module.emrapi.conditionslist.Condition condition1 = getCondition("uuid_one"); org.openmrs.module.emrapi.conditionslist.Condition condition2 = getCondition("uuid_two"); org.openmrs.module.emrapi.conditionslist.Condition condition3 = getCondition("uuid_three"); conditionHistory.setConditions(Arrays.asList(condition1, condition2, condition3)); conditionHistory.setCondition(new Concept()); ConditionHistory conditionHistoryContract = conditionHistoryMapper.map(conditionHistory); assertEquals("uuid_one", conditionHistoryContract.getConditions().get(0).getUuid()); assertEquals("uuid_two", conditionHistoryContract.getConditions().get(1).getUuid()); assertEquals("uuid_three", conditionHistoryContract.getConditions().get(2).getUuid()); }
@Test public void shouldMapConditionHistoryModalsToListOfContracts() throws Exception { org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory1 = new org.openmrs.module.emrapi.conditionslist.ConditionHistory(); org.openmrs.module.emrapi.conditionslist.Condition condition1 = getCondition("uuid_one"); org.openmrs.module.emrapi.conditionslist.Condition condition2 = getCondition("uuid_two"); org.openmrs.module.emrapi.conditionslist.Condition condition3 = getCondition("uuid_three"); conditionHistory1.setConditions(Arrays.asList(condition1, condition2, condition3)); conditionHistory1.setCondition(new Concept()); org.openmrs.module.emrapi.conditionslist.ConditionHistory conditionHistory2 = new org.openmrs.module.emrapi.conditionslist.ConditionHistory(); org.openmrs.module.emrapi.conditionslist.Condition condition4 = getCondition("uuid_four"); org.openmrs.module.emrapi.conditionslist.Condition condition5 = getCondition("uuid_five"); org.openmrs.module.emrapi.conditionslist.Condition condition6 = getCondition("uuid_six"); conditionHistory2.setConditions(Arrays.asList(condition4, condition5, condition6)); conditionHistory2.setCondition(new Concept()); List<ConditionHistory> conditionHistoryContracts = conditionHistoryMapper.map(Arrays.asList(conditionHistory1, conditionHistory2)); List<Condition> conditions1 = conditionHistoryContracts.get(0).getConditions(); List<Condition> conditions2 = conditionHistoryContracts.get(1).getConditions(); assertEquals("uuid_one", conditions1.get(0).getUuid()); assertEquals("uuid_two", conditions1.get(1).getUuid()); assertEquals("uuid_three", conditions1.get(2).getUuid()); assertEquals("uuid_four", conditions2.get(0).getUuid()); assertEquals("uuid_five", conditions2.get(1).getUuid()); assertEquals("uuid_six", conditions2.get(2).getUuid()); }
|
### Question:
ConditionServiceImpl extends BaseOpenmrsService implements ConditionService { public List<ConditionHistory> getConditionHistory(Patient patient) { List<Condition> conditionList = conditionDAO.getConditionHistory(patient); Map<String, ConditionHistory> allConditions = new LinkedHashMap<String, ConditionHistory>(); for (Condition condition : conditionList) { Concept concept = condition.getConcept(); String nonCodedConceptUuid = administrationService.getGlobalProperty( ConditionListConstants.GLOBAL_PROPERTY_NON_CODED_UUID); String key = concept.getUuid().equals(nonCodedConceptUuid) ? condition.getConditionNonCoded() : concept.getUuid(); ConditionHistory conditionHistory = allConditions.get(key); if (conditionHistory != null) { conditionHistory.getConditions().add(condition); } else { conditionHistory = new ConditionHistory(); List<Condition> conditions = new ArrayList<Condition>(); conditions.add(condition); conditionHistory.setConditions(conditions); conditionHistory.setCondition(condition.getConcept()); if (concept.getUuid().equals(nonCodedConceptUuid)) { conditionHistory.setNonCodedCondition(condition.getConditionNonCoded()); } } allConditions.put(key, conditionHistory); } return new ArrayList<ConditionHistory>(allConditions.values()); } ConditionServiceImpl(ConditionDAO conditionDAO, ConceptService conceptService,
AdministrationService administrationService); @Override Condition save(Condition condition); List<ConditionHistory> getConditionHistory(Patient patient); @Override Condition voidCondition(Condition condition, String voidReason); @Override Condition getConditionByUuid(String uuid); @Override List<Condition> getActiveConditions(Patient patient); @Override @Transactional(readOnly = true) List<Concept> getEndReasonConcepts(); }### Answer:
@Test public void shouldGetConditionHistoryReturnListOfConditionHistoryGroupedByConceptForPatient() { Patient patient = patientService.getPatient(3); List<ConditionHistory> conditionHistoryForPatient = conditionService.getConditionHistory(patient); assertEquals(conditionHistoryForPatient.size(), 4); assertThat(conditionHistoryForPatient, contains(new ConditionHistoryMatcher("severe", 1), new ConditionHistoryMatcher("pain", 1), new ConditionHistoryMatcher("Angina", 1), new ConditionHistoryMatcher("Tuberculosis", 1))); }
|
### Question:
EmrPatientProfileServiceImpl implements EmrPatientProfileService { @Override public PatientProfile get(String patientUuid) { PatientProfile delegate = new PatientProfile(); Patient patient = patientService.getPatientByUuid(patientUuid); delegate.setPatient(patient); Person person = personService.getPerson(patient.getPersonId()); List<Relationship> relationships = personService.getRelationshipsByPerson(person); delegate.setRelationships(relationships); return delegate; } @Override PatientProfile save(PatientProfile patientProfile); @Override PatientProfile get(String patientUuid); void setPatientService(PatientService patientService); void setPersonService(PersonService personService); void setEmrPersonImageService(EmrPersonImageService emrPersonImageService); }### Answer:
@Test public void shouldGetPatientProfile() throws Exception { PatientProfile patientProfile = emrPatientProfileService.get("patient_uuid"); assertNotNull(patientProfile.getPatient()); assertEquals(patientProfile.getPatient().getUuid(), "patient_uuid"); assertEquals(patientProfile.getRelationships().size(), 1); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public boolean isUnknownPatient() { boolean unknownPatient = false; PersonAttributeType unknownPatientAttributeType = emrApiProperties.getUnknownPatientPersonAttributeType(); if (patient != null) { PersonAttribute att = patient.getAttribute(unknownPatientAttributeType); if (att != null && "true".equals(att.getValue())) { unknownPatient = true; } } return unknownPatient; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldVerifyIfPatientIsUnknown() { PersonAttributeType personAttributeType = new PersonAttributeType(); personAttributeType.setPersonAttributeTypeId(10); personAttributeType.setName(EmrApiConstants.UNKNOWN_PATIENT_PERSON_ATTRIBUTE_TYPE_NAME); personAttributeType.setFormat("java.lang.String"); PersonAttribute newAttribute = new PersonAttribute(personAttributeType, "true"); patient.addAttribute(newAttribute); when(emrApiProperties.getUnknownPatientPersonAttributeType()).thenReturn(personAttributeType); assertTrue(patientDomainWrapper.isUnknownPatient()); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public boolean isTestPatient() { boolean testPatient = false; PersonAttributeType testPatientPersonAttributeType = emrApiProperties.getTestPatientPersonAttributeType(); if (patient != null) { PersonAttribute att = patient.getAttribute(testPatientPersonAttributeType); if (att != null && "true".equals(att.getValue())) { testPatient = true; } } return testPatient; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldVerifyIfPatientIsATest() { PersonAttributeType personAttributeType = new PersonAttributeType(); personAttributeType.setPersonAttributeTypeId(11); personAttributeType.setName("Test Patient"); personAttributeType.setFormat("java.lang.Boolean"); personAttributeType.setUuid(EmrApiConstants.TEST_PATIENT_ATTRIBUTE_UUID); PersonAttribute newAttribute = new PersonAttribute(personAttributeType, "true"); patient.addAttribute(newAttribute); when(emrApiProperties.getTestPatientPersonAttributeType()).thenReturn(personAttributeType); assertTrue(patientDomainWrapper.isTestPatient()); }
@Test public void shouldVerifyIfPatientIsNotATest() { PersonAttributeType personAttributeType = new PersonAttributeType(); personAttributeType.setPersonAttributeTypeId(11); personAttributeType.setName("Test Patient"); personAttributeType.setFormat("java.lang.Boolean"); personAttributeType.setUuid(EmrApiConstants.TEST_PATIENT_ATTRIBUTE_UUID); PersonAttribute newAttribute = new PersonAttribute(personAttributeType, "false"); patient.addAttribute(newAttribute); when(emrApiProperties.getTestPatientPersonAttributeType()).thenReturn(personAttributeType); assertFalse(patientDomainWrapper.isTestPatient()); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public List<VisitDomainWrapper> getAllVisitsUsingWrappers() { return getVisitsByTypeUsingWrappers(null); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldCreateAListOfVisitDomainWrappersBasedOnVisitListFromVisitService() { when(visitService.getVisitsByPatient(patient, true, false)).thenReturn(asList(new Visit(), new Visit(), new Visit())); when(domainWrapperFactory.newVisitDomainWrapper(any(Visit.class))).thenReturn(new VisitDomainWrapper()); List<VisitDomainWrapper> visitDomainWrappers = patientDomainWrapper.getAllVisitsUsingWrappers(); assertThat(visitDomainWrappers.size(), is(3)); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public String getFormattedName() { return getPersonName().getFamilyName() + ", " + getPersonName().getGivenName(); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldReturnFormattedName() { patient = mock(Patient.class); patientDomainWrapper = new PatientDomainWrapper(patient, emrApiProperties, mock(AdtService.class), visitService, mock(EncounterService.class), mock(DiagnosisService.class), mock(DomainWrapperFactory.class)); Set<PersonName> personNames = new HashSet<PersonName>(); PersonName personNamePreferred = createPreferredPersonName("John", "Dover"); personNames.add(personNamePreferred); when(patient.getNames()).thenReturn(personNames); String formattedName = patientDomainWrapper.getFormattedName(); assertThat(formattedName, is("Dover, John")); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public PersonName getPersonName() { Set<PersonName> names = patient.getNames(); if (names != null && names.size() > 0) { for (PersonName name : names) { if (name.isPreferred()) return name; } for (PersonName name : names) { return name; } } return null; } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldReturnPersonNameWhenThereAreTwoNamesAndOneOfThemIsPreferred() { patient = mock(Patient.class); patientDomainWrapper = new PatientDomainWrapper(patient, emrApiProperties, mock(AdtService.class), visitService, mock(EncounterService.class), mock(DiagnosisService.class), mock(DomainWrapperFactory.class)); Set<PersonName> personNames = new HashSet<PersonName>(); PersonName personNamePreferred = createPreferredPersonName("mario", "neissi"); personNames.add(personNamePreferred); PersonName personNameNonPreferred = createNonPreferredPersonName("Ana", "emerson"); personNames.add(personNameNonPreferred); when(patient.getNames()).thenReturn(personNames); PersonName returnedName = patientDomainWrapper.getPersonName(); assertSame(personNamePreferred, returnedName); }
@Test public void shouldReturnPersonNameWhenThereAreTwoNamesAndNoneOfThemIsPreferred() { patient = mock(Patient.class); patientDomainWrapper = new PatientDomainWrapper(patient, emrApiProperties, mock(AdtService.class), visitService, mock(EncounterService.class), mock(DiagnosisService.class), mock(DomainWrapperFactory.class)); Set<PersonName> personNames = new HashSet<PersonName>(); PersonName personNamePreferred = createNonPreferredPersonName("mario", "neissi"); personNames.add(personNamePreferred); PersonName personNameNonPreferred = createNonPreferredPersonName("Ana", "emerson"); personNames.add(personNameNonPreferred); when(patient.getNames()).thenReturn(personNames); PersonName returnedName = patientDomainWrapper.getPersonName(); assertNotNull(returnedName); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public Integer getAgeInMonths() { if (patient.getBirthdate() == null) { return null; } Date endDate = patient.isDead() ? patient.getDeathDate() : new Date(); return Months.monthsBetween(new DateTime(patient.getBirthdate()), new DateTime(endDate)).getMonths(); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldCalculateCorrectAgeInMonthsForDeceasedPatient() { patient.setDead(true); Calendar cal = Calendar.getInstance(); cal.set(2012, 11, 4); patient.setBirthdate(cal.getTime()); cal.set(2013, 2, 1); patient.setDeathDate(cal.getTime()); assertThat(patientDomainWrapper.getAgeInMonths(), is(2)); }
|
### Question:
PatientDomainWrapper implements DomainWrapper { public Integer getAgeInDays() { if (patient.getBirthdate() == null) { return null; } Date endDate = patient.isDead() ? patient.getDeathDate() : new Date(); return Days.daysBetween(new DateTime(patient.getBirthdate()), new DateTime(endDate)).getDays(); } PatientDomainWrapper(); @Deprecated // use the PatientDomainWrapperFactory component to instantiate a new PDW PatientDomainWrapper(Patient patient, EmrApiProperties emrApiProperties, AdtService adtService,
VisitService visitService, EncounterService encounterService, DiagnosisService diagnosisService, DomainWrapperFactory domainWrapperFactory); void setPatient(Patient patient); void setEmrApiProperties(EmrApiProperties emrApiProperties); void setAdtService(AdtService adtService); void setVisitService(VisitService visitService); void setEncounterService(EncounterService encounterService); void setDiagnosisService(DiagnosisService diagnosisService); void setVisitQueryService(VisitQueryService visitQueryService); Patient getPatient(); Integer getId(); String getGender(); Integer getAge(); Integer getAgeInMonths(); Integer getAgeInDays(); Boolean getBirthdateEstimated(); Date getBirthdate(); String getTelephoneNumber(); PersonAddress getPersonAddress(); PatientIdentifier getPrimaryIdentifier(); List<PatientIdentifier> getPrimaryIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(); List<PatientIdentifier> getExtraIdentifiers(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(Location location); Map<PatientIdentifierType, List<PatientIdentifier>> getExtraIdentifiersMappedByType(); Encounter getLastEncounter(); VisitDomainWrapper getActiveVisit(Location location); int getCountOfEncounters(); int getCountOfVisits(); List<Encounter> getAllEncounters(); List<Visit> getVisitsByType(VisitType visitType); List<Visit> getAllVisits(); boolean hasOverlappingVisitsWith(Patient otherPatient); boolean isUnknownPatient(); List<VisitDomainWrapper> getVisitsByTypeUsingWrappers(VisitType visitType); List<VisitDomainWrapper> getAllVisitsUsingWrappers(); String getFormattedName(); PersonName getPersonName(); boolean isTestPatient(); List<Diagnosis> getDiagnosesSince(Date date); List<Diagnosis> getUniqueDiagnosesSince(Date date); }### Answer:
@Test public void shouldCalculateCorrectAgeInDaysForDeceasedPatient() { patient.setDead(true); Calendar cal = Calendar.getInstance(); cal.set(2013, 1, 26); patient.setBirthdate(cal.getTime()); cal.set(2013, 2, 1); patient.setDeathDate(cal.getTime()); assertThat(patientDomainWrapper.getAgeInDays(), is(3)); }
|
### Question:
AccountDomainWrapper implements DomainWrapper { public Boolean getUserEnabled() { if (user == null) { return null; } else { return !user.isRetired(); } } AccountDomainWrapper(); @Deprecated // use DomainWrapperFactory instead AccountDomainWrapper(Person person, AccountService accountService, UserService userService, ProviderService providerService,
ProviderManagementService providerManagementService, PersonService personService,
ProviderIdentifierGenerator providerIdentifierGenerator); void setAccountService(AccountService accountService); void setUserService(UserService userService); void setProviderService(ProviderService providerService); void setPersonService(PersonService personService); void setProviderManagementService(ProviderManagementService providerManagementService); void setProviderIdentifierGenerator(ProviderIdentifierGenerator providerIdentifierGenerator); void initializeWithPerson(Person person); Person getPerson(); User getUser(); Provider getProvider(); void setProviderRole(ProviderRole providerRole); ProviderRole getProviderRole(); void setGivenName(String givenName); String getGivenName(); void setFamilyName(String familyName); String getFamilyName(); void setGender(String gender); String getGender(); void setUsername(String username); String getUsername(); String getPassword(); void setPassword(String password); String getConfirmPassword(); void setConfirmPassword(String confirmPassword); void setDefaultLocale(Locale locale); Locale getDefaultLocale(); void setPrivilegeLevel(Role privilegeLevel); Role getPrivilegeLevel(); void setCapabilities(Set<Role> capabilities); Set<Role> getCapabilities(); void setUserEnabled(Boolean userEnabled); Boolean getUserEnabled(); boolean isLocked(); void unlock(); void save(); }### Answer:
@Test public void shouldReturnFalseIfUserRetired() { Person person = new Person(); person.setId(1); User user = new User(); user.setPerson(person); user.setRetired(true); when(userService.getUsersByPerson(eq(person), eq(false))).thenReturn(Collections.singletonList(user)); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); Assert.assertFalse(account.getUserEnabled()); }
@Test public void shouldReturnTrueIfUserNotRetired() { Person person = new Person(); person.setId(1); User user = new User(); user.setPerson(person); user.setRetired(false); when(userService.getUsersByPerson(eq(person), eq(false))).thenReturn(Collections.singletonList(user)); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); Assert.assertTrue(account.getUserEnabled()); }
@Test public void shouldReturnNullIfNoUser() { Person person = new Person(); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); Assert.assertNull(account.getUserEnabled()); }
|
### Question:
AccountDomainWrapper implements DomainWrapper { public void save() { if (person != null) { personService.savePerson(person); } if (user != null) { boolean existingUser = (user.getUserId() != null); if (!existingUser) { userService.createUser(user, password); } else { try { Method saveUser = UserService.class.getDeclaredMethod("saveUser", User.class); saveUser.invoke(userService, user); } catch (Exception e) { userService.createUser(user, password); } } if (existingUser && StringUtils.isNotBlank(password) && StringUtils.isNotBlank(confirmPassword)) { userService.changePassword(user, password); } } if (provider != null) { providerService.saveProvider(provider); if (providerIdentifierGenerator != null && StringUtils.isBlank(provider.getIdentifier())) { provider.setIdentifier(providerIdentifierGenerator.generateIdentifier(provider)); providerService.saveProvider(provider); } } } AccountDomainWrapper(); @Deprecated // use DomainWrapperFactory instead AccountDomainWrapper(Person person, AccountService accountService, UserService userService, ProviderService providerService,
ProviderManagementService providerManagementService, PersonService personService,
ProviderIdentifierGenerator providerIdentifierGenerator); void setAccountService(AccountService accountService); void setUserService(UserService userService); void setProviderService(ProviderService providerService); void setPersonService(PersonService personService); void setProviderManagementService(ProviderManagementService providerManagementService); void setProviderIdentifierGenerator(ProviderIdentifierGenerator providerIdentifierGenerator); void initializeWithPerson(Person person); Person getPerson(); User getUser(); Provider getProvider(); void setProviderRole(ProviderRole providerRole); ProviderRole getProviderRole(); void setGivenName(String givenName); String getGivenName(); void setFamilyName(String familyName); String getFamilyName(); void setGender(String gender); String getGender(); void setUsername(String username); String getUsername(); String getPassword(); void setPassword(String password); String getConfirmPassword(); void setConfirmPassword(String confirmPassword); void setDefaultLocale(Locale locale); Locale getDefaultLocale(); void setPrivilegeLevel(Role privilegeLevel); Role getPrivilegeLevel(); void setCapabilities(Set<Role> capabilities); Set<Role> getCapabilities(); void setUserEnabled(Boolean userEnabled); Boolean getUserEnabled(); boolean isLocked(); void unlock(); void save(); }### Answer:
@Test public void testSaveAccountWithOnlyPerson() throws Exception { Person person = new Person(); AccountDomainWrapper account = initializeNewAccountDomainWrapper(person); account.save(); verify(personService).savePerson(person); verify(userService, never()).createUser(any(User.class), anyString()); }
|
### Question:
OrderMetadataService { public OrderFrequency getOrderFrequencyByName(String conceptName, boolean includeRetired) { List<OrderFrequency> orderFrequencies = orderService.getOrderFrequencies(includeRetired); for (OrderFrequency orderFrequency : orderFrequencies) { if(orderFrequency.getName().equals(conceptName)){ return orderFrequency; } } return null; } @Autowired OrderMetadataService(OrderService orderService); Concept getDurationUnitsConceptByName(String conceptName); OrderFrequency getOrderFrequencyByName(String conceptName, boolean includeRetired); }### Answer:
@Test public void shouldGetOrderFrequencyByName() throws Exception { OrderFrequency onceADayOrderFrequency = new OrderFrequency(); onceADayOrderFrequency.setConcept(createConcept(ONCE_A_DAY_CONCEPT_NAME)); OrderFrequency twiceADayOrderFrequency = new OrderFrequency(); twiceADayOrderFrequency.setConcept(createConcept(TWICE_A_DAY_CONCEPT_NAME)); when(orderService.getOrderFrequencies(false)).thenReturn(Arrays.asList(onceADayOrderFrequency, twiceADayOrderFrequency)); OrderFrequency orderFrequency = orderMetadataService.getOrderFrequencyByName(ONCE_A_DAY_CONCEPT_NAME, false); assertThat(orderFrequency, is(onceADayOrderFrequency)); }
@Test public void shouldReturnNullIfOrderFrequencyNotPresent() throws Exception { when(orderService.getOrderFrequencies(false)).thenReturn(new ArrayList<OrderFrequency>()); OrderFrequency orderFrequency = orderMetadataService.getOrderFrequencyByName(ONCE_A_DAY_CONCEPT_NAME, false); assertNull(orderFrequency); }
@Test public void shouldReturnNullOrderFrequencyForNullInput() { assertNull(orderMetadataService.getOrderFrequencyByName(null, false)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public boolean isDisposition(Obs obs) { return obs.getConcept().equals(dispositionSetConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldReturnTrueWhenPassedInDispositionObsGroup() { Obs dispositionSet = createDispositionObsGroup(); assertTrue(dispositionDescriptor.isDisposition(dispositionSet)); }
@Test public void shouldReturnFalseWhenPassedInNonDispositionObsGroup() { Obs notDispositionSet = new Obs(); Concept notDispositionConcept = new Concept(); notDispositionSet.setConcept(notDispositionConcept); assertFalse(dispositionDescriptor.isDisposition(notDispositionSet)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService) { Obs dispoObs = new Obs(); dispoObs.setConcept(dispositionConcept); dispoObs.setValueCoded(emrConceptService.getConcept(disposition.getConceptCode())); Obs group = new Obs(); group.setConcept(dispositionSetConcept); group.addGroupMember(dispoObs); return group; } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldBuildDispositionObsGroup() { Disposition admissionDisposition = new Disposition(); admissionDisposition.setConceptCode("ADMISSION"); Obs dispositionObsGroup = dispositionDescriptor.buildObsGroup(admissionDisposition, emrConceptService); assertThat(dispositionObsGroup.getConcept(), is(dispositionSetConcept)); assertTrue(dispositionObsGroup.hasGroupMembers()); assertThat(dispositionObsGroup.getGroupMembers().size(), is(1)); Obs dispositionObs = dispositionObsGroup.getGroupMembers().iterator().next(); assertThat(dispositionObs.getConcept(), is(dispositionConcept)); assertThat(dispositionObs.getValueCoded(), is(admissionConcept)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs getAdmissionLocationObs(Obs obsGroup) { return findMember(obsGroup, admissionLocationConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchAdmissionLocationObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs admissionLocation = new Obs(); admissionLocation.setConcept(admissionLocationConcept); dispositionObsGroup.addGroupMember(admissionLocation); assertThat(dispositionDescriptor.getAdmissionLocationObs(dispositionObsGroup), is(admissionLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingAdmissionLocationObs() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getAdmissionLocationObs(dispositionObsGroup)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs getInternalTransferLocationObs(Obs obsGroup) { return findMember(obsGroup, internalTransferLocationConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchTransferLocationObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs transferLocation = new Obs(); transferLocation.setConcept(transferLocationConcept); dispositionObsGroup.addGroupMember(transferLocation); assertThat(dispositionDescriptor.getInternalTransferLocationObs(dispositionObsGroup), is(transferLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingTransferLocationOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getInternalTransferLocationObs(dispositionObsGroup)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Obs getDateOfDeathObs(Obs obsGroup) { return findMember(obsGroup, dateOfDeathConcept); } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchDateOfDeathObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs dateOfDeath = new Obs(); dateOfDeath.setConcept(dateOfDeathConcept); dispositionObsGroup.addGroupMember(dateOfDeath); assertThat(dispositionDescriptor.getDateOfDeathObs(dispositionObsGroup), is(dateOfDeath)); }
@Test public void shouldNotFailIfNoMatchingObsWhenDateOfDeath() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getDateOfDeathObs(dispositionObsGroup)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Location getAdmissionLocation(Obs obsGroup, LocationService locationService) { Obs admissionLocationObs = getAdmissionLocationObs(obsGroup); if (admissionLocationObs != null) { return locationService.getLocation(Integer.valueOf(admissionLocationObs.getValueText())); } else { return null; } } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchAdmissionLocationOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs admissionLocationObs = new Obs(); admissionLocationObs.setConcept(admissionLocationConcept); admissionLocationObs.setValueText(admissionLocation.getId().toString()); dispositionObsGroup.addGroupMember(admissionLocationObs); assertThat(dispositionDescriptor.getAdmissionLocation(dispositionObsGroup, locationService), is(admissionLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingAdmissionLocation() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getAdmissionLocation(dispositionObsGroup, locationService)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Location getInternalTransferLocation(Obs obsGroup, LocationService locationService) { Obs transferLocationObs = getInternalTransferLocationObs(obsGroup); if (transferLocationObs != null) { return locationService.getLocation(Integer.valueOf(transferLocationObs.getValueText())); } else { return null; } } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchTransferLocationOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs transferLocationObs = new Obs(); transferLocationObs.setConcept(transferLocationConcept); transferLocationObs.setValueText(transferLocation.getId().toString()); dispositionObsGroup.addGroupMember(transferLocationObs); assertThat(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService), is(transferLocation)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingTransferLocation() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getInternalTransferLocation(dispositionObsGroup, locationService)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public Date getDateOfDeath(Obs obsGroup) { Obs dateOfDeathObs = getDateOfDeathObs(obsGroup); if (dateOfDeathObs != null) { return dateOfDeathObs.getValueDate(); } else { return null; } } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchDateOfDeathOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Date dateOfDeath = new Date(); Obs dateOfDeathObs = new Obs(); dateOfDeathObs.setConcept(dateOfDeathConcept); dateOfDeathObs.setValueDate(dateOfDeath); dispositionObsGroup.addGroupMember(dateOfDeathObs); assertThat(dispositionDescriptor.getDateOfDeath(dispositionObsGroup), is(dateOfDeath)); }
@Test public void shouldNotFailIfNoMatchingObsWhenFetchingDateOfDeath() { Obs dispositionObsGroup = createDispositionObsGroup(); assertNull(dispositionDescriptor.getDateOfDeath(dispositionObsGroup)); }
|
### Question:
DispositionDescriptor extends ConceptSetDescriptor { public List<Obs> getAdditionalObs(Obs obsGroup) { List<Obs> notDisposition = new ArrayList<Obs>(); if (obsGroup.hasGroupMembers()) { for (Obs candidate : obsGroup.getGroupMembers()) { if (!candidate.getConcept().equals(dispositionConcept) && !candidate.getConcept().equals(admissionLocationConcept) && !candidate.getConcept().equals(internalTransferLocationConcept) && !candidate.getConcept().equals(dateOfDeathConcept)) { notDisposition.add(candidate); } } } return notDisposition; } DispositionDescriptor(ConceptService conceptService); DispositionDescriptor(); Concept getDispositionSetConcept(); void setDispositionSetConcept(Concept dispositionSetConcept); Concept getDispositionConcept(); void setDispositionConcept(Concept dispositionConcept); Concept getAdmissionLocationConcept(); void setAdmissionLocationConcept(Concept admissionLocationConcept); Concept getInternalTransferLocationConcept(); void setInternalTransferLocationConcept(Concept internalTransferLocationConcept); Concept getDateOfDeathConcept(); void setDateOfDeathConcept(Concept dateOfDeathConcept); Obs buildObsGroup(Disposition disposition, EmrConceptService emrConceptService); boolean isDisposition(Obs obs); Obs getDispositionObs(Obs obsGroup); Obs getAdmissionLocationObs(Obs obsGroup); Obs getInternalTransferLocationObs(Obs obsGroup); Obs getDateOfDeathObs(Obs obsGroup); Location getAdmissionLocation(Obs obsGroup, LocationService locationService); Location getInternalTransferLocation(Obs obsGroup, LocationService locationService); Date getDateOfDeath(Obs obsGroup); List<Obs> getAdditionalObs(Obs obsGroup); }### Answer:
@Test public void shouldFetchAdditionalObsOffObsGroup() { Obs dispositionObsGroup = createDispositionObsGroup(); Obs admissionLocationObs = new Obs(); admissionLocationObs.setConcept(admissionLocationConcept); admissionLocationObs.setValueText(admissionLocation.getId().toString()); dispositionObsGroup.addGroupMember(admissionLocationObs); Obs transferLocationObs = new Obs(); transferLocationObs.setConcept(transferLocationConcept); transferLocationObs.setValueText(transferLocation.getId().toString()); dispositionObsGroup.addGroupMember(transferLocationObs); Date dateOfDeath = new Date(); Obs dateOfDeathObs = new Obs(); dateOfDeathObs.setConcept(dateOfDeathConcept); dateOfDeathObs.setValueDate(dateOfDeath); dispositionObsGroup.addGroupMember(dateOfDeathObs); Concept additionalObsConcept = new Concept(); Obs additionalObs = new Obs(); additionalObs.setConcept(additionalObsConcept); additionalObs.setValueText("some value"); dispositionObsGroup.addGroupMember(additionalObs); List<Obs> additionalObsList = Collections.singletonList(additionalObs); assertThat(dispositionDescriptor.getAdditionalObs(dispositionObsGroup), is(additionalObsList)); }
|
### Question:
DischargeIfAdmittedDispositionAction implements DispositionAction { @Override public void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters) { Visit visit = encounterDomainWrapper.getVisit(); VisitDomainWrapper visitDomainWrapper = adtService.wrap(visit); if (visitDomainWrapper.isAdmitted()) { AdtAction discharge = new AdtAction(visit, encounterDomainWrapper.getLocation(), encounterDomainWrapper.getProviders(), DISCHARGE); discharge.setActionDatetime(encounterDomainWrapper.getEncounter().getEncounterDatetime()); adtService.createAdtEncounterFor(discharge); } } @Override void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters); void setAdtService(AdtService adtService); void setEmrApiProperties(EmrApiProperties emrApiProperties); }### Answer:
@Test public void testDischargesIfAdmitted() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); when(visitDomainWrapper.isAdmitted()).thenReturn(true); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService).createAdtEncounterFor(argThat(new ArgumentMatcher<AdtAction>() { @Override public boolean matches(Object argument) { AdtAction actual = (AdtAction) argument; return actual.getVisit().equals(visit) && TestUtils.sameProviders(actual.getProviders(), encounter.getProvidersByRoles()) && actual.getActionDatetime().equals(encounterDate) && actual.getType().equals(AdtAction.Type.DISCHARGE); } })); }
@Test public void testDoesNotDischargesIfNotAdmitted() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(false); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService, never()).createAdtEncounterFor(any(AdtAction.class)); }
|
### Question:
AdmitToSpecificLocationDispositionAction implements DispositionAction { @Override public void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters) { VisitDomainWrapper visitDomainWrapper = adtService.wrap(encounterDomainWrapper.getVisit()); if (visitDomainWrapper.isAdmitted(encounterDomainWrapper.getEncounterDatetime()) || visitDomainWrapper.isAdmitted()) { return; } else { Location admissionLocation = dispositionService.getDispositionDescriptor().getAdmissionLocation(dispositionObsGroupBeingCreated, locationService); if (admissionLocation != null) { AdtAction admission = new AdtAction(encounterDomainWrapper.getVisit(), admissionLocation, encounterDomainWrapper.getProviders(), ADMISSION); admission.setActionDatetime(encounterDomainWrapper.getEncounter().getEncounterDatetime()); adtService.createAdtEncounterFor(admission); } else { log.warn("Unable to create admission action, no admission location specified in obsgroup " + dispositionObsGroupBeingCreated); } } } @Override void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters); void setLocationService(LocationService locationService); void setAdtService(AdtService adtService); void setDispositionService(DispositionService dispositionService); }### Answer:
@Test public void testAction() throws Exception { final Location toLocation = new Location(); final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); encounter.addObs(dispositionObsGroup); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(false); when(dispositionDescriptor.getAdmissionLocation(dispositionObsGroup, locationService)).thenReturn(toLocation); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); verify(adtService).createAdtEncounterFor(argThat(new ArgumentMatcher<AdtAction>() { @Override public boolean matches(Object argument) { AdtAction actual = (AdtAction) argument; return actual.getVisit().equals(visit) && actual.getLocation().equals(toLocation) && TestUtils.sameProviders(actual.getProviders(), encounter.getProvidersByRoles()) && actual.getActionDatetime().equals(encounterDate) && actual.getType().equals(AdtAction.Type.ADMISSION); } })); }
@Test public void testActionWhenAlreadyAdmitted() throws Exception { final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); when(visitDomainWrapper.isAdmitted(encounterDate)).thenReturn(false); action.action(new EncounterDomainWrapper(encounter), new Obs(), new HashMap<String, String[]>()); verify(adtService, never()).createAdtEncounterFor(any(AdtAction.class)); }
|
### Question:
MarkPatientDeadDispositionAction implements DispositionAction { @Override public void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters) { Date deathDate = dispositionService.getDispositionDescriptor().getDateOfDeath(dispositionObsGroupBeingCreated); Concept causeOfDeath = emrApiProperties.getUnknownCauseOfDeathConcept(); Patient patient = encounterDomainWrapper.getEncounter().getPatient(); patient.setDead(true); if (deathDate != null) { patient.setDeathDate(deathDate); } patient.setCauseOfDeath(causeOfDeath); patientService.savePatient(patient); } @Override void action(EncounterDomainWrapper encounterDomainWrapper, Obs dispositionObsGroupBeingCreated, Map<String, String[]> requestParameters); void setPatientService(PatientService patientService); void setDispositionService(DispositionService dispositionService); void setEmrApiProperties(EmrApiProperties emrApiProperties); }### Answer:
@Test public void testActionShouldMarkPatientAsDead() throws Exception { Concept unknown = new Concept(); when(emrApiProperties.getUnknownCauseOfDeathConcept()).thenReturn(unknown); Date expectedDeathDate = (new DateTime(2013, 05, 10, 20, 26)).toDate(); Patient patient = new Patient(); final Visit visit = new Visit(); final Encounter encounter = new Encounter(); final Date encounterDate = (new DateTime(2013, 05, 13, 20, 26)).toDate(); encounter.setVisit(visit); encounter.addProvider(new EncounterRole(), new Provider()); encounter.setEncounterDatetime(encounterDate); encounter.setPatient(patient); final Obs dispositionObsGroup = new Obs(); dispositionObsGroup.setConcept(dispositionObsGroupConcept); encounter.addObs(dispositionObsGroup); when(dispositionDescriptor.getDateOfDeath(dispositionObsGroup)).thenReturn(expectedDeathDate); action.action(new EncounterDomainWrapper(encounter), dispositionObsGroup, null); assertThat(patient.isDead(), is(true)); assertThat(patient.getDeathDate(), is(expectedDeathDate)); assertThat(patient.getCauseOfDeath(), is(unknown)); verify(patientService).savePatient(patient); }
|
### Question:
ConceptSetDescriptor { protected void setup(ConceptService conceptService, String conceptSourceName, ConceptSetDescriptorField primaryConceptField, ConceptSetDescriptorField... memberConceptFields) { try { String primaryConceptCode = primaryConceptField.getConceptCode(); Concept primaryConcept = conceptService.getConceptByMapping(primaryConceptCode, conceptSourceName); if (primaryConcept == null) { throw new MissingConceptException("Couldn't find primary concept for " + getClass().getSimpleName() + " which should be mapped as " + conceptSourceName + ":" + primaryConceptCode); } PropertyUtils.setProperty(this, primaryConceptField.getName(), primaryConcept); for (ConceptSetDescriptorField conceptSetDescriptorField : memberConceptFields) { String propertyName = conceptSetDescriptorField.getName(); String mappingCode = conceptSetDescriptorField.getConceptCode(); Concept childConcept = conceptService.getConceptByMapping(mappingCode, conceptSourceName); if(conceptSetDescriptorField.isRequired()) { if (childConcept == null) { throw new MissingConceptException("Couldn't find " + propertyName + " concept for " + getClass().getSimpleName() + " which should be mapped as " + conceptSourceName + ":" + mappingCode); } if (!primaryConcept.getSetMembers().contains(childConcept)) { throw new IllegalStateException("Concept mapped as " + conceptSourceName + ":" + mappingCode + " needs to be a set member of concept " + primaryConcept.getConceptId() + " which is mapped as " + conceptSourceName + ":" + primaryConceptCode); } } PropertyUtils.setProperty(this, propertyName, childConcept); } } catch (Exception ex) { if (ex instanceof RuntimeException) { throw (RuntimeException) ex; } else { throw new IllegalStateException(ex); } } } }### Answer:
@Test public void shouldProperlySetupConcepts() { ConceptSetDescriptorImpl conceptSetDescriptorImpl = new ConceptSetDescriptorImpl(); conceptSetDescriptorImpl.setup(conceptService, "someConceptSource", ConceptSetDescriptorField.required("setConcept", "setConceptCode"), ConceptSetDescriptorField.required("firstMemberConcept", "firstMemberConceptCode"), ConceptSetDescriptorField.required("secondMemberConcept", "secondMemberConceptCode")); assertThat(conceptSetDescriptorImpl.getSetConcept(), is(setConcept)); assertThat(conceptSetDescriptorImpl.getFirstMemberConcept(), is(firstMemberConcept)); assertThat(conceptSetDescriptorImpl.getSecondMemberConcept(), is(secondMemberConcept)); }
@Test(expected = IllegalStateException.class) public void shouldRaiseExceptionIfRequiredConceptDoesNotExist() { ConceptSetDescriptorImpl conceptSetDescriptorImpl = new ConceptSetDescriptorImpl(); conceptSetDescriptorImpl.setup(conceptService, "someConceptSource", ConceptSetDescriptorField.required("setConcept", "setConceptCode"), ConceptSetDescriptorField.required("firstMemberConcept", "nonExistingConceptCode")); }
@Test public void shouldNotRaiseExceptionIfOptionalConceptDoesNotExist() { ConceptSetDescriptorImpl conceptSetDescriptorImpl = new ConceptSetDescriptorImpl(); conceptSetDescriptorImpl.setup(conceptService, "someConceptSource", ConceptSetDescriptorField.required("setConcept", "setConceptCode"), ConceptSetDescriptorField.optional("firstMemberConcept", "nonExistingConceptCode")); assertThat(conceptSetDescriptorImpl.getSetConcept(), is(setConcept)); assertThat(conceptSetDescriptorImpl.getFirstMemberConcept(), IsNull.nullValue()); }
|
### Question:
NoteFrequencyCalculator { public double getFrequency(Note note) { int semitonesPerOctave = 12; int referenceOctave = 4; double distance = semitonesPerOctave * (note.getOctave() - referenceOctave); distance += notes.indexOf(note.getName() + note.getSign()) - notes.indexOf("A"); return referenceFrequency * Math.pow(2, distance / 12); } NoteFrequencyCalculator(float referenceFrequency); double getFrequency(Note note); }### Answer:
@Test public void TestCalc() { InputStream resourceAsStream = getClass().getResourceAsStream("note_frequencies.csv"); try (BufferedReader reader = new BufferedReader(new InputStreamReader(resourceAsStream))) { while (reader.ready()) { String line = reader.readLine(); String[] components = line.split(","); String noteWithOctave = components[0].split("/")[0]; String frequency = components[1]; String noteName = noteWithOctave.substring(0, 1); String octave = noteWithOctave.substring(1); String sign = ""; if (noteWithOctave.contains("#")) { noteName = noteWithOctave.substring(0, 1); octave = noteWithOctave.substring(2); sign = "#"; } String finalNoteName = noteName; String finalOctave = octave; String finalSign = sign; Note note = new Note() { @Override public NoteName getName() { return NoteName.fromScientificName(finalNoteName); } @Override public int getOctave() { return Integer.parseInt(finalOctave); } @Override public String getSign() { return finalSign; } }; NoteFrequencyCalculator noteFrequencyCalculator = new NoteFrequencyCalculator(440); double expectedFrequency = Double.parseDouble(frequency); double actualFrequency = noteFrequencyCalculator.getFrequency(note); Assert.assertEquals(expectedFrequency, actualFrequency, 0.01); } } catch (IOException e) { Assert.fail(e.getMessage()); } }
|
### Question:
PitchComparator { static PitchDifference retrieveNote(float pitch) { Tuning tuning = MainActivity.getCurrentTuning(); int referencePitch = MainActivity.getReferencePitch(); Note[] notes = tuning.getNotes(); NoteFrequencyCalculator noteFrequencyCalculator = new NoteFrequencyCalculator(referencePitch); Arrays.sort(notes, (o1, o2) -> Double.compare(noteFrequencyCalculator.getFrequency(o1), noteFrequencyCalculator.getFrequency(o2))); double minCentDifference = Float.POSITIVE_INFINITY; Note closest = notes[0]; for (Note note : notes) { double frequency = noteFrequencyCalculator.getFrequency(note); double centDifference = 1200d * log2(pitch / frequency); if (Math.abs(centDifference) < Math.abs(minCentDifference)) { minCentDifference = centDifference; closest = note; } } return new PitchDifference(closest, minCentDifference); } }### Answer:
@Test public void retrieveNote() { PowerMockito.mockStatic(MainActivity.class); Mockito.when(MainActivity.getCurrentTuning()).thenReturn(new GuitarTuning()); Mockito.when(MainActivity.getReferencePitch()).thenReturn(440); Map<Float, PitchDifference> expectations = new HashMap<>(); expectations.put(20f, new PitchDifference(E2, -2451.3202694972874)); expectations.put(500f, new PitchDifference(E4, 721.3071582323822)); expectations.put(197.67f, new PitchDifference(G3, 14.705999652460953)); expectations.put(128.415f, new PitchDifference(D3, -232.0232233030192)); for (Float pitch : expectations.keySet()) { PitchDifference actual = PitchComparator.retrieveNote(pitch); PitchDifference expected = expectations.get(pitch); assertNotNull(expected); assertThat(actual.closest, is(expected.closest)); assertThat(actual.deviation, closeTo(expected.deviation, 0.01)); } }
|
### Question:
Sampler { static PitchDifference calculateAverageDifference(List<PitchDifference> samples) { Note mostFrequentNote = extractMostFrequentNote(samples); List<PitchDifference> filteredSamples = filterByNote(samples, mostFrequentNote); double deviationSum = 0; int sameNoteCount = 0; for (PitchDifference pitchDifference : filteredSamples) { deviationSum += pitchDifference.deviation; sameNoteCount++; } if (sameNoteCount > 0) { double averageDeviation = deviationSum / sameNoteCount; return new PitchDifference(mostFrequentNote, averageDeviation); } return null; } }### Answer:
@Test public void the_average_difference_is_calculated_correctly() { List<PitchDifference> samples = new ArrayList<>(); samples.add(new PitchDifference(E2, 2.46D)); samples.add(new PitchDifference(E2, -10.3D)); samples.add(new PitchDifference(E2, 5.71D)); samples.add(new PitchDifference(E2, 12.532D)); samples.add(new PitchDifference(E2, -0.414D)); PitchDifference pitchDifference = calculateAverageDifference(samples); double average = (2.46D - 10.3D + 5.71D + 12.532D - 0.414D) / 5D; assertNotNull(pitchDifference); assertThat(pitchDifference.closest.getName(), is(E2.getName())); assertThat(pitchDifference.deviation, closeTo(average, 0.001)); }
|
### Question:
Sampler { static List<PitchDifference> filterByNote(List<PitchDifference> samples, Note note) { List<PitchDifference> filteredSamples = new ArrayList<>(); for (PitchDifference sample : samples) { if (sample.closest == note) { filteredSamples.add(sample); } } return filteredSamples; } }### Answer:
@Test public void samples_are_filtered_correctly() { List<PitchDifference> samples = new ArrayList<>(); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(B3, 3D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(G3, 4D)); samples.add(new PitchDifference(B3, 3D)); List<PitchDifference> filteredSamples = filterByNote(samples, B3); for (PitchDifference sample : filteredSamples) { assertThat(sample.closest.getName(), is(B3.getName())); } }
|
### Question:
Sampler { static Note extractMostFrequentNote(List<PitchDifference> samples) { Map<Note, Integer> noteFrequencies = new HashMap<>(); for (PitchDifference pitchDifference : samples) { Note closest = pitchDifference.closest; if (noteFrequencies.containsKey(closest)) { Integer count = noteFrequencies.get(closest); noteFrequencies.put(closest, count + 1); } else { noteFrequencies.put(closest, 1); } } Note mostFrequentNote = null; int mostOccurrences = 0; for (Note note : noteFrequencies.keySet()) { Integer occurrences = noteFrequencies.get(note); if (occurrences > mostOccurrences) { mostFrequentNote = note; mostOccurrences = occurrences; } } return mostFrequentNote; } }### Answer:
@Test public void the_most_frequent_note_is_extracted_correctly() { List<PitchDifference> samples = new ArrayList<>(); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(B3, 3D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(G3, 4D)); samples.add(new PitchDifference(B3, 3D)); Note note = extractMostFrequentNote(samples); assertThat(note.getName(), is(E2.getName())); }
@Test public void if_there_are_notes_with_the_same_number_of_occurrences_one_of_them_is_returned() { List<PitchDifference> samples = new ArrayList<>(); samples.add(new PitchDifference(G3, 2D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(B3, 3D)); samples.add(new PitchDifference(E2, 2D)); samples.add(new PitchDifference(B3, 3D)); Note note = extractMostFrequentNote(samples); assertThat(note.getName(), either(is(E2.getName())).or(is(B3.getName()))); }
|
### Question:
FormatService { public static SerializationFormat getInputFormat(String name) { for (SerializationFormat ft : Instance.serializationFormats) { if (ft.isAcceptedAsInput(name)) { return ft; } } return null; } private FormatService(); static SerializationFormat getInputFormat(String name); static SerializationFormat getOutputFormat(String name); static String getFormatFromExtension(String filename); }### Answer:
@Test public void testGetInputFormat() { assertEquals(FormatService.getInputFormat("turtle"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getInputFormat("ttl"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getInputFormat("ntriples"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getInputFormat("N-Triple"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getInputFormat("n3"), SerializationFormatFactory.createN3()); assertEquals(FormatService.getInputFormat("RDF/XML"), SerializationFormatFactory.createRDFXMLIn()); assertEquals(FormatService.getInputFormat("rdfxml"), SerializationFormatFactory.createRDFXMLIn()); assertEquals(FormatService.getInputFormat("RDF/XML-ABBREV"), SerializationFormatFactory.createRDFXMLIn()); assertEquals(FormatService.getInputFormat("RDFA"), SerializationFormatFactory.createRDFa()); }
|
### Question:
RDFUnitUtils { public static void fillSchemaServiceFromLOV() throws IOException { log.info("Loading cached schema entries from LOV!"); RDFUnitUtils.fillSchemaServiceFromResource("org/aksw/rdfunit/configuration/schemaLOV.csv"); } private RDFUnitUtils(); static void fillSchemaServiceFromFile(String additionalCSV); static void fillSchemaServiceWithStandardVocabularies(); static void fillSchemaServiceFromSchemaDecl(); static void fillSchemaServiceFromLOV(); static Optional<T> getFirstItemInCollection(Collection<T> collection); static List<SchemaSource> augmentWithOwlImports(Set<SchemaSource> originalSources); }### Answer:
@Test public void fillSchemaServiceFromLOVTest() throws IOException { int currentSize = SchemaService.getSize(); RDFUnitUtils.fillSchemaServiceFromLOV(); assertThat(SchemaService.getSize()) .isGreaterThan(currentSize); }
|
### Question:
RDFUnitUtils { public static void fillSchemaServiceFromSchemaDecl() throws IOException { log.info("Adding manual schema entries (or overriding LOV)!"); RDFUnitUtils.fillSchemaServiceFromResource("org/aksw/rdfunit/configuration/schemaDecl.csv"); } private RDFUnitUtils(); static void fillSchemaServiceFromFile(String additionalCSV); static void fillSchemaServiceWithStandardVocabularies(); static void fillSchemaServiceFromSchemaDecl(); static void fillSchemaServiceFromLOV(); static Optional<T> getFirstItemInCollection(Collection<T> collection); static List<SchemaSource> augmentWithOwlImports(Set<SchemaSource> originalSources); }### Answer:
@Test public void fillSchemaServiceFromDeclTest() throws IOException { int currentSize = SchemaService.getSize(); RDFUnitUtils.fillSchemaServiceFromSchemaDecl(); assertThat(SchemaService.getSize()) .isGreaterThan(currentSize); }
|
### Question:
RDFUnitStaticValidator { public static TestExecution validate(final Model inputModel) throws Exception { return validate(inputModel, TestCaseExecutionType.shaclTestCaseResult); } private RDFUnitStaticValidator(); static void initWrapper(@NonNull RDFUnitTestSuiteGenerator testSuiteGenerator); static TestSuite getTestSuite(); static TestExecution validate(final Model inputModel); static TestExecution validate(final Model inputModel, final TestCaseExecutionType executionType); static TestExecution validate(final Model inputModel, final String inputURI); static TestExecution validate(final Model inputModel, final TestCaseExecutionType executionType, final String inputURI); static TestExecution validate(final Model inputModel, final TestCaseExecutionType executionType, final String inputURI, DatasetOverviewResults overviewResults); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final Model model, final TestSuite testSuite); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final TestSource testSource, final TestSuite testSuite); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final TestSource testSource, final TestSuite testSuite, DatasetOverviewResults overviewResults); static TestExecution validate(final TestCaseExecutionType testCaseExecutionType, final TestSource testSource, final TestSuite testSuite, final String agentID, DatasetOverviewResults overviewResults); }### Answer:
@Test public void testValidateModel() throws Exception { RDFUnitStaticValidator.validate(ModelFactory.createDefaultModel(), testCaseExecutionType); }
|
### Question:
PrefixNSService { public static String getNSFromPrefix(final String prefix) { return MapInstance.prefixNsBidiMap.get(prefix); } private PrefixNSService(); static String getNSFromPrefix(final String prefix); static String getPrefixFromNS(final String namespace); static void setNSPrefixesInModel(Model model); static String getSparqlPrefixDecl(); static String getURIFromAbbrev(final String abbreviation); static String getLocalName(final String uri, final String prefix); }### Answer:
@Test public void testGetPrefix() throws IOException { Model prefixModel = ModelFactory.createDefaultModel(); try (InputStream is = org.aksw.rdfunit.services.PrefixNSService.class.getResourceAsStream(Resources.PREFIXES)) { prefixModel.read(is, null, "TURTLE"); } Map<String, String> prefixes = prefixModel.getNsPrefixMap(); for (Map.Entry<String, String> entry : prefixes.entrySet()) { String uri = org.aksw.rdfunit.services.PrefixNSService.getNSFromPrefix(entry.getKey()); Assert.assertEquals("All prefixed should be initialized", uri, entry.getValue()); } }
|
### Question:
PatternWriter implements ElementWriter { @Override public Resource write(Model model) { Resource resource = ElementWriter.copyElementResourceInModel(pattern, model); resource .addProperty(RDF.type, RDFUNITv.Pattern) .addProperty(DCTerms.identifier, pattern.getId()) .addProperty(DCTerms.description, pattern.getDescription()) .addProperty(RDFUNITv.sparqlWherePattern, pattern.getSparqlWherePattern()); if (pattern.getSparqlPatternPrevalence().isPresent()) { resource.addProperty(RDFUNITv.sparqlPrevalencePattern, pattern.getSparqlPatternPrevalence().get()); } for (PatternParameter patternParameter: pattern.getParameters()) { Resource parameter = PatternParameterWriter.create(patternParameter).write(model); resource.addProperty(RDFUNITv.parameter, parameter); } for (ResultAnnotation resultAnnotation: pattern.getResultAnnotations()) { Resource annotationResource = ResultAnnotationWriter.create(resultAnnotation).write(model); resource.addProperty(RDFUNITv.resultAnnotation, annotationResource); } return resource; } private PatternWriter(Pattern pattern); static PatternWriter create(Pattern pattern); @Override Resource write(Model model); }### Answer:
@Test public void testWrite() throws RdfReaderException, RdfWriterException { Model inputModel = RdfReaderFactory.createResourceReader(Resources.PATTERNS).read(); Collection<Pattern> patterns = BatchPatternReader.create().getPatternsFromModel(inputModel); Model outputModel = ModelFactory.createDefaultModel(); for (Pattern pattern: patterns) { PatternWriter.create(pattern).write(outputModel); } assertThat(inputModel.isIsomorphicWith(outputModel)).isTrue(); }
|
### Question:
ShaclModel { public Set<GenericTestCase> generateTestCases() { return allShapeGroup.stream().flatMap(groupShape -> getGenericTestCase(groupShape).values().stream().flatMap(Collection::stream)).collect(Collectors.toSet()); } ShaclModel(Model inputShaclGraph); Set<GenericTestCase> generateTestCases(); }### Answer:
@Test public void testRead() throws RdfReaderException { ShaclModel shaclModel = new ShaclModel(RdfReaderFactory.createResourceReader(shapeResource).read()); Set<GenericTestCase> tests = shaclModel.generateTestCases(); assertThat(tests) .isNotEmpty(); }
|
### Question:
ShapeReader implements ElementReader<Shape> { @Override public Shape read(Resource resource) { checkNotNull(resource); ShapeImpl.ShapeImplBuilder shapeBuilder = ShapeImpl.builder(); shapeBuilder .element(resource) .propertyValuePairSets(PropertyValuePairSet.createFromResource(resource)); Resource path = resource.getPropertyResourceValue(SHACL.path); if (path != null) { shapeBuilder.shaclPath( ShapePathReader.create().read(path) ); } return shapeBuilder.build(); } private ShapeReader(); static ShapeReader create(); @Override Shape read(Resource resource); }### Answer:
@Test public void testRead() throws RdfReaderException { Model shapesModel = RdfReaderFactory.createResourceReader(shapeResource).read(); List<Shape> shapes = shapesModel.listResourcesWithProperty(RDF.type, SHACL.Shape).toList() .stream() .map( r -> ShapeReader.create().read(r)) .collect(Collectors.toList()); assertThat(shapes) .hasSize(1); Shape sh = shapes.get(0); checkTarget(sh); }
|
### Question:
ComponentReader implements ElementReader<Component> { @Override public Component read(Resource resource) { checkNotNull(resource); ComponentImpl.ComponentImplBuilder componentBuilder = ComponentImpl.builder(); componentBuilder.element(resource); for (Statement smt : resource.listProperties(SHACL.parameter).toList()) { Resource obj = smt.getObject().asResource(); ComponentParameter cp = ComponentParameterReader.create().read(obj); componentBuilder.parameter(cp); } for (Statement smt : resource.listProperties(SHACL.validator).toList()) { Resource obj = smt.getObject().asResource(); ComponentValidator cv = ComponentValidatorReader.create(ComponentValidatorType.ASK_VALIDATOR).read(obj); componentBuilder.validator(cv); } for (Statement smt : resource.listProperties(SHACL.nodeValidator).toList()) { Resource obj = smt.getObject().asResource(); ComponentValidator cv = ComponentValidatorReader.create(ComponentValidatorType.NODE_VALIDATOR).read(obj); componentBuilder.validator(cv); } for (Statement smt : resource.listProperties(SHACL.propertyValidator).toList()) { Resource obj = smt.getObject().asResource(); ComponentValidator cv = ComponentValidatorReader.create(ComponentValidatorType.PROPERTY_VALIDATOR).read(obj); componentBuilder.validator(cv); } return componentBuilder.build(); } private ComponentReader(); static ComponentReader create(); @Override Component read(Resource resource); }### Answer:
@Test public void testRead() { Component c = ComponentReader.create().read(resource); int i = 0; }
|
### Question:
SparqlValidatorReader implements ElementReader<Validator> { @Override public Validator read(Resource resource) { checkNotNull(resource); SparqlValidatorImpl.SparqlValidatorImplBuilder validatorBuilder = SparqlValidatorImpl.builder(); validatorBuilder.element(resource); for (Statement smt : resource.listProperties(SHACL.message).toList()) { validatorBuilder.message(smt.getObject().asLiteral()); } for (Statement smt : resource.listProperties(SHACL.prefixes).toList()) { RDFNode obj = smt.getObject(); if (obj.isResource()) { validatorBuilder.prefixDeclarations(BatchPrefixDeclarationReader.create().getPrefixDeclarations(obj.asResource())); } } for (Statement smt : resource.listProperties(SHACL.select).toList()) { validatorBuilder.sparqlQuery(smt.getObject().asLiteral().getLexicalForm()); } return validatorBuilder.build(); } private SparqlValidatorReader(); static SparqlValidatorReader create(); @Override Validator read(Resource resource); }### Answer:
@Test public void testRead() { SparqlValidatorReader.create().read(resource); }
|
### Question:
FormatService { public static SerializationFormat getOutputFormat(String name) { for (SerializationFormat ft : Instance.serializationFormats) { if (ft.isAcceptedAsOutput(name)) { return ft; } } return null; } private FormatService(); static SerializationFormat getInputFormat(String name); static SerializationFormat getOutputFormat(String name); static String getFormatFromExtension(String filename); }### Answer:
@Test public void testGetOutputFormat() { assertEquals(FormatService.getOutputFormat("turtle"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getOutputFormat("ttl"), SerializationFormatFactory.createTurtle()); assertEquals(FormatService.getOutputFormat("ntriples"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getOutputFormat("N-Triple"), SerializationFormatFactory.createNTriples()); assertEquals(FormatService.getOutputFormat("n3"), SerializationFormatFactory.createN3()); assertEquals(FormatService.getOutputFormat("RDF/XML"), SerializationFormatFactory.createRDFXMLOut()); assertEquals(FormatService.getOutputFormat("rdfxml"), SerializationFormatFactory.createRDFXMLOut()); assertEquals(FormatService.getOutputFormat("RDF/XML-ABBREV"), SerializationFormatFactory.createRDFXMLAbbrevOut()); }
|
### Question:
ShapePathReader implements ElementReader<ShapePath> { @Override public ShapePath read(Resource resource) { checkNotNull(resource); ShapePathImpl.ShapePathImplBuilder shapePathBuilder = ShapePathImpl.builder(); shapePathBuilder.element(resource); shapePathBuilder.jenaPath(readPath(resource)); return shapePathBuilder.build(); } private ShapePathReader(); static ShapePathReader create(); @Override ShapePath read(Resource resource); }### Answer:
@Test public void testRead() { assertThat(ShapePathReader.create().read(shaclPath).asSparqlPropertyPath()) .isEqualTo(propertyPathString); }
|
### Question:
ComponentValidatorReader implements ElementReader<ComponentValidator> { @Override public ComponentValidator read(Resource resource) { checkNotNull(resource); ComponentValidatorImpl.ComponentValidatorImplBuilder validatorBuilder = ComponentValidatorImpl.builder(); validatorBuilder.element(resource); validatorBuilder.type(type); for (Statement smt : resource.listProperties(SHACL.message).toList()) { validatorBuilder.message(smt.getObject().asLiteral()); } for (Statement smt : resource.listProperties(SHACL.prefixes).toList()) { RDFNode obj = smt.getObject(); if (obj.isResource()) { validatorBuilder.prefixDeclarations(BatchPrefixDeclarationReader.create().getPrefixDeclarations(obj.asResource())); } } for (Statement smt : resource.listProperties(SHACL.ask).toList()) { checkArgument(type.equals(ComponentValidatorType.ASK_VALIDATOR), "SPARQL SELECT-Based Validator contains ASK query: %s", smt.getObject().asLiteral().getLexicalForm()); validatorBuilder.sparqlQuery(smt.getObject().asLiteral().getLexicalForm()); } for (Statement smt : resource.listProperties(SHACL.select).toList()) { checkArgument(!type.equals(ComponentValidatorType.ASK_VALIDATOR), "SPARQL ASK-Based Validator contains SELECT query %s", smt.getObject().asLiteral().getLexicalForm()); validatorBuilder.sparqlQuery(smt.getObject().asLiteral().getLexicalForm()); } for (Statement smt : resource.listProperties(RDFUNIT_SHACL_EXT.filter).toList()) { validatorBuilder.filter(smt.getObject().asLiteral().getLexicalForm()); } return validatorBuilder.build(); } private ComponentValidatorReader(ComponentValidatorType type); static ComponentValidatorReader create(ComponentValidatorType type); @Override ComponentValidator read(Resource resource); }### Answer:
@Test public void testRead() { ComponentValidatorReader.create(ComponentValidatorType.ASK_VALIDATOR).read(resource); }
|
### Question:
ComponentParameterReader implements ElementReader<ComponentParameter> { @Override public ComponentParameter read(Resource resource) { checkNotNull(resource); ComponentParameterImpl.ComponentParameterImplBuilder argumentBuilder = ComponentParameterImpl.builder(); argumentBuilder.element(resource); for (Statement smt : resource.listProperties(SHACL.path).toList()) { argumentBuilder = argumentBuilder.predicate(ResourceFactory.createProperty(smt.getObject().asResource().getURI())); } checkNotNull(argumentBuilder); for (Statement smt : resource.listProperties(SHACL.defaultValue).toList()) { argumentBuilder.defaultValue(smt.getObject()); } for (Statement smt : resource.listProperties(SHACL.optional).toList()) { argumentBuilder.isOptional(smt.getObject().asLiteral().getBoolean()); } return argumentBuilder.build(); } private ComponentParameterReader(); static ComponentParameterReader create(); @Override ComponentParameter read(Resource resource); }### Answer:
@Test public void testRead() { ComponentParameterReader.create().read(resource); }
|
### Question:
BatchShapeTargetReader { public Set<ShapeTarget> read(Resource resource) { checkNotNull(resource); ImmutableSet.Builder<ShapeTarget> targetBuilder = ImmutableSet.builder(); targetBuilder.addAll(collectExplicitTargets(resource)); return targetBuilder.build(); } private BatchShapeTargetReader(); static BatchShapeTargetReader create(); Set<ShapeTarget> read(Resource resource); }### Answer:
@Test public void testRead() throws RdfReaderException { Model shapesModel = RdfReaderFactory.createResourceReader(shapeResource).read(); Resource r1 = shapesModel.getResource("http: Set<ShapeTarget> targets1 = BatchShapeTargetReader.create().read(r1); assertThat(targets1) .hasSize(2); }
|
### Question:
PatternReader implements ElementReader<Pattern> { @Override public Pattern read(Resource resource) { checkNotNull(resource); PatternImpl.Builder patternBuilder = new PatternImpl.Builder(); patternBuilder.setElement(resource); int count; count = 0; for (Statement smt : resource.listProperties(DCTerms.identifier).toList()) { checkArgument(++count == 1, "Cannot have more than one identifier in Pattern %s", resource.getURI()); patternBuilder.setId(smt.getObject().asLiteral().getLexicalForm()); } count = 0; for (Statement smt : resource.listProperties(DCTerms.description).toList()) { checkArgument(++count == 1, "Cannot have more than one description in Pattern %s", resource.getURI()); patternBuilder.setDescription(smt.getObject().asLiteral().getLexicalForm()); } count = 0; for (Statement smt : resource.listProperties(RDFUNITv.sparqlWherePattern).toList()) { checkArgument(++count == 1, "Cannot have more than one SPARQL query in Pattern %s", resource.getURI()); patternBuilder.setSparqlWherePattern(smt.getObject().asLiteral().getLexicalForm()); } count = 0; for (Statement smt : resource.listProperties(RDFUNITv.sparqlPrevalencePattern).toList()) { checkArgument(++count == 1, "Cannot have more than one prevalence query in Pattern %s", resource.getURI()); patternBuilder.setSparqlPatternPrevalence(smt.getObject().asLiteral().getLexicalForm()); } Collection<PatternParameter> patternParameters = resource.listProperties(RDFUNITv.parameter).toList().stream() .map(smt -> PatternParameterReader.create().read(smt.getResource())) .collect(Collectors.toCollection(ArrayList::new)); patternBuilder.setParameters(patternParameters); Collection<ResultAnnotation> patternAnnotations = resource.listProperties(RDFUNITv.resultAnnotation).toList().stream() .map(smt -> ResultAnnotationReader.create().read(smt.getResource())) .collect(Collectors.toList()); patternBuilder.setAnnotations(patternAnnotations); return patternBuilder.build(); } private PatternReader(); static PatternReader create(); @Override Pattern read(Resource resource); }### Answer:
@Test public void testRead() { PatternReader.create().read(resource); }
|
### Question:
PatternParameterReader implements ElementReader<PatternParameter> { @Override public PatternParameter read(Resource resource) { checkNotNull(resource); PatternParameterImpl.Builder parameterBuilder = new PatternParameterImpl.Builder(); parameterBuilder.setElement(resource); for (Statement smt : resource.listProperties(DCTerms.identifier).toList()) { parameterBuilder.setID(smt.getObject().asLiteral().getLexicalForm()); } for (Statement smt : resource.listProperties(RDFUNITv.parameterConstraint).toList()) { parameterBuilder.setPatternParameterConstraints(smt.getObject().asResource().getURI()); } for (Statement smt : resource.listProperties(RDFUNITv.constraintPattern).toList()) { parameterBuilder.setConstraintPattern(smt.getObject().asLiteral().getLexicalForm()); } return parameterBuilder.build(); } private PatternParameterReader(); static PatternParameterReader create(); @Override PatternParameter read(Resource resource); }### Answer:
@Test public void testRead() { PatternParameterReader.create().read(resource); }
|
### Question:
SelectVar { public static SelectVar create(String name) { return new SelectVar(name, name); } static SelectVar create(String name); static SelectVar create(String name, String label); String asString(); }### Answer:
@Test public void testCreate() { String varName = "test"; SelectVar selectVar = SelectVar.create(varName); assertThat(selectVar.getName()) .isEqualTo(varName); assertThat(selectVar.getLabel()) .isEqualTo(varName); assertThat(selectVar.asString()) .isEqualTo(" ?" + varName + " "); }
@Test(expected=NullPointerException.class) public void testNull() { SelectVar.create(null); }
|
### Question:
AnnotationTemplate { public void addTemplateMin(Property property, int minOccurs) { template.put(property, Range.atLeast(minOccurs)); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testAddTemplateMin() { AnnotationTemplate at = AnnotationTemplate.create(); assertThat(at.existsInTemplate(sa1)).isFalse(); at.addTemplateMin(RDF.type, 2); assertThat(at.existsInTemplate(sa1)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa1)).isFalse(); assertThat(at.existsInTemplate(sa2)).isFalse(); at.addTemplateMin(RDF.predicate, 2); assertThat(at.existsInTemplate(sa2)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa2)).isTrue(); }
|
### Question:
AnnotationTemplate { public void addTemplateMax(Property property, int maxOccurs) { template.put(property, Range.atMost(maxOccurs)); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testAddTemplateMax() { AnnotationTemplate at = AnnotationTemplate.create(); assertThat(at.existsInTemplate(sa1)).isFalse(); at.addTemplateMax(RDF.type, 1); assertThat(at.existsInTemplate(sa1)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa1)).isTrue(); assertThat(at.existsInTemplate(sa2)).isFalse(); assertThat(at.isValidAccordingToTemplate(sa2)).isFalse(); at.addTemplateMax(RDF.predicate, 1); assertThat(at.existsInTemplate(sa2)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa2)).isFalse(); }
|
### Question:
FormatService { public static String getFormatFromExtension(String filename) { String format = "TURTLE"; try { String extension; Lang jenaLang = RDFLanguages.filenameToLang(filename); if (jenaLang != null) { extension = jenaLang.getFileExtensions().get(0); } else { int index = filename.lastIndexOf('.'); extension = filename.substring(index + 1, filename.length()); } SerializationFormat f = FormatService.getInputFormat(extension); if (f != null) { format = f.getName(); } } catch (Exception e) { log.debug("No format found, using the default one", e); return "TURTLE"; } return format; } private FormatService(); static SerializationFormat getInputFormat(String name); static SerializationFormat getOutputFormat(String name); static String getFormatFromExtension(String filename); }### Answer:
@Test public void testGetFormatFromExtension() { Map<String, String> testVals = new HashMap<>(); testVals.put("asdf.ttl", "TURTLE"); testVals.put("asdf.nt", "N-TRIPLE"); testVals.put("asdf.n3", "N3"); testVals.put("asdf.jsonld", "JSON-LD"); testVals.put("asdf.rj", "RDF/JSON"); testVals.put("asdf.rdf", "RDF/XML"); testVals.put("asdf.nq", "NQuads"); testVals.put("asdf.trix", "TriX"); testVals.put("asdf.trig", "TriG"); testVals.put("asdf.html", "RDFA"); for (Map.Entry<String, String> entry: testVals.entrySet()) { assertEquals("Should be equal", entry.getValue(), FormatService.getFormatFromExtension(entry.getKey())); } }
|
### Question:
AnnotationTemplate { public void addTemplateMinMax(Property property, int minOccurs, int maxOccurs) { template.put(property, Range.closed(minOccurs, maxOccurs)); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testAddTemplateMinMax() { AnnotationTemplate at = AnnotationTemplate.create(); assertThat(at.existsInTemplate(sa1)).isFalse(); at.addTemplateMinMax(RDF.type, 1, 2); assertThat(at.existsInTemplate(sa1)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa1)).isTrue(); assertThat(at.existsInTemplate(sa2)).isFalse(); at.addTemplateMinMax(RDF.predicate, 3, 5); assertThat(at.existsInTemplate(sa2)).isTrue(); assertThat(at.isValidAccordingToTemplate(sa2)).isFalse(); }
|
### Question:
AnnotationTemplate { public Set<Property> getPropertiesAsSet() { return template.keySet(); } private AnnotationTemplate(); static AnnotationTemplate create(); void addTemplateMin(Property property, int minOccurs); void addTemplateMax(Property property, int maxOccurs); void addTemplateMinMax(Property property, int minOccurs, int maxOccurs); Set<Property> getPropertiesAsSet(); boolean existsInTemplate(PropertyValuePair propertyValuePair); boolean isValidAccordingToTemplate(PropertyValuePair propertyValuePair); }### Answer:
@Test public void testGetPropertiesAsSet() { AnnotationTemplate at = AnnotationTemplate.create(); at.addTemplateMinMax(RDF.type, 1,2); at.addTemplateMinMax(RDF.predicate, 3,5); assertThat(at.getPropertiesAsSet()).isNotEmpty(); assertThat(at.getPropertiesAsSet().size()).isEqualTo(2); }
|
### Question:
ShapeTargetCore implements ShapeTarget { public static ShapeTarget create(@NonNull ShapeTargetType targetType, @NonNull RDFNode node) { switch (targetType) { case ClassTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::classTargetPattern); case NodeTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::nodeTargetPattern); case ObjectsOfTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::objectsOfTargetPattern); case SubjectsOfTarget: return new ShapeTargetCore(targetType, node, ShapeTargetCore::subjectsOfTargetPattern); default: throw new IllegalArgumentException("Something wrong with the input"); } } private ShapeTargetCore(ShapeTargetType targetType, RDFNode node, Function<RDFNode, String> generatePattern); @Override String getPattern(); @Override Set<Resource> getRelatedOntologyResources(); static ShapeTarget create(@NonNull ShapeTargetType targetType, @NonNull RDFNode node); }### Answer:
@Test(expected=NullPointerException.class) public void testCreateNullType() { ShapeTargetCore.create(null, null); }
@Test public void testPatternUnique() { List<String> targetPatterns = Arrays.stream(ShapeTargetType.values() ) .filter( sct -> !sct.equals(ShapeTargetType.ValueShapeTarget)) .map( s -> ShapeTargetCore.create(s, ResourceFactory.createResource("http: .map(ShapeTarget::getPattern) .collect(Collectors.toList()); assertThat(targetPatterns.size()) .isEqualTo(new HashSet<>(targetPatterns).size()); }
|
### Question:
ComponentParameterImpl implements ComponentParameter { @Override public Optional<RDFNode> getDefaultValue() { return Optional.ofNullable(defaultValue); } @Override Optional<RDFNode> getDefaultValue(); }### Answer:
@Test public void testGetDefaultValue() { assertThat(argDef.getDefaultValue().isPresent()) .isFalse(); RDFNode node = ResourceFactory.createResource("http: ComponentParameterImpl arg2 = ComponentParameterImpl.builder().element(element).predicate(predicate).defaultValue(node).build(); assertThat(arg2.getDefaultValue().get()) .isEqualTo(node); }
|
### Question:
RdfUnitJunitRunner extends ParentRunner<RdfUnitJunitTestCase> { protected RdfReader getAdditionalDataModel() { return additionalData; } RdfUnitJunitRunner(Class<?> testClass); static final Class<?> INPUT_DATA_RETURN_TYPE; }### Answer:
@Test public void returnsVocabulary() throws InitializationError { final RdfUnitJunitRunner rdfUnitJunitRunner = new RdfUnitJunitRunner(ControlledVocabularyTest.class); assertThat(rdfUnitJunitRunner.getAdditionalDataModel()).isSameAs(CONTROLLED_VOCABULARY); }
|
### Question:
MetricMapper { public static MetricMapper createDefault() { Model model; try { model = RdfReaderFactory.createResourceReader("/org/aksw/rdfunit/dqv/metricMappings.ttl").read(); } catch (RdfReaderException e) { throw new IllegalArgumentException("Cannot read default metric mappings", e); } ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<>(); model.listStatements().toList().stream() .filter(smt -> smt.getPredicate().equals(RDFUNITv.metric)) .filter(smt -> smt.getObject().isResource()) .forEach(smt -> builder.put(smt.getSubject().getURI(), smt.getObject().asResource().getURI())); return new MetricMapper(builder.build()); } private MetricMapper(ImmutableMap<String, String> metricMap); Map<String, String> getMetricMap(); static MetricMapper createDefault(); }### Answer:
@Test public void testCreateDefault() { MetricMapper metricMapper = MetricMapper.createDefault(); int DEFAULT_MAP_SIZE = 16; assertThat(metricMapper.getMetricMap().size()) .isEqualTo(DEFAULT_MAP_SIZE); }
|
### Question:
RdfFirstSuccessReader implements RdfReader { @Override public void read(Model model) throws RdfReaderException { StringBuilder message = new StringBuilder(); for (RdfReader r : readers) { try { r.read(model); return; } catch (RdfReaderException e) { message.append('\n'); if (e.getMessage() != null) { message.append(e.getMessage()); } else { message.append(e); } } } throw new RdfReaderException("Cannot read from any reader: " + message.toString()); } RdfFirstSuccessReader(Collection<RdfReader> readers); @Override void read(Model model); @Override void readDataset(Dataset dataset); @Override String toString(); }### Answer:
@Test public void testNotExceptionRead() { ArrayList<RdfReader> rdfReaders = new ArrayList<>(); rdfReaders.add(new RdfStreamReader("")); rdfReaders.add(RdfReaderFactory.createResourceReader("/org/aksw/rdfunit/io/empty.ttl")); RdfFirstSuccessReader reader = new RdfFirstSuccessReader(rdfReaders); try { reader.read(); } catch (RdfReaderException e) { fail("Should have NOT raised a TripleReaderException"); } }
|
### Question:
RdfFirstSuccessReader implements RdfReader { @Override public void readDataset(Dataset dataset) throws RdfReaderException { StringBuilder message = new StringBuilder(); for (RdfReader r : readers) { try { r.readDataset(dataset); return; } catch (RdfReaderException e) { message.append("\n"); if (e.getMessage() != null) { message.append(e.getMessage()); } else { message.append(e); } } } throw new RdfReaderException("Cannot read from any reader: " + message.toString()); } RdfFirstSuccessReader(Collection<RdfReader> readers); @Override void read(Model model); @Override void readDataset(Dataset dataset); @Override String toString(); }### Answer:
@Test public void testNotExceptionReadDataset() { ArrayList<RdfReader> rdfReaders = new ArrayList<>(); rdfReaders.add(new RdfStreamReader("")); rdfReaders.add(RdfReaderFactory.createResourceReader("/org/aksw/rdfunit/io/empty.ttl")); RdfFirstSuccessReader reader = new RdfFirstSuccessReader(rdfReaders); try { reader.readDataset(); } catch (RdfReaderException e) { Assert.fail("Should have NOT raised a TripleReaderException"); } }
|
### Question:
RdfStreamReader implements RdfReader { @Override public void read(Model model) throws RdfReaderException { try { RDFDataMgr.read(model, inputStream, null, RDFLanguages.nameToLang(format)); } catch (Exception e) { throw new RdfReaderException(e.getMessage(), e); } } RdfStreamReader(String filename); RdfStreamReader(String filename, String format); RdfStreamReader(InputStream inputStream, String format); @Override void read(Model model); @Override void readDataset(Dataset dataset); @Override String toString(); }### Answer:
@Test public void testReader() throws Exception{ Model readModel = RdfReaderFactory.createResourceReader(resourceName).read(); assertTrue("Models not the same", model.isIsomorphicWith(readModel)); }
|
### Question:
RdfReaderFactory { public static RdfReader createReaderFromText(String text, String format) { InputStream is; is = new ByteArrayInputStream(text.getBytes(StandardCharsets.UTF_8)); return new RdfStreamReader(is, format); } private RdfReaderFactory(); static RdfReader createFileOrDereferenceReader(String filename, String uri); static RdfReader createResourceReader(String resource); static RdfReader createFileOrResourceReader(String filename, String resource); static RdfReader createResourceOrFileOrDereferenceReader(String uri); static RdfReader createDereferenceReader(String uri); static RdfReader createReaderFromText(String text, String format); static RdfReader createEmptyReader(); }### Answer:
@Test public void testCreateReaderFromText() throws IOException, RdfReaderException { URL url = Resources.getResource(this.getClass(),"/org/aksw/rdfunit/io/onetriple.ttl"); String content = Resources.toString(url, Charsets.UTF_8); RdfReader reader = RdfReaderFactory.createReaderFromText(content, "TTL"); Model model = reader.read(); assertThat(model.isIsomorphicWith(ReaderTestUtils.createOneTripleModel())).isTrue(); }
|
### Question:
NamespaceStatistics { public Collection<SchemaSource> getNamespaces(QueryExecutionFactory qef) { Set<String> namespaces = new HashSet<>(); for (DatasetStatistics dt : datasetStatistics) { namespaces.addAll(dt.getStatisticsMap(qef).keySet().stream() .map(this::getNamespaceFromURI) .collect(Collectors.toList())); } return getIdentifiedSchemata(namespaces); } private NamespaceStatistics(Collection<DatasetStatistics> datasetStatisticses, boolean skipUnknownNamespaces, RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsAll(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsAll(RDFUnitConfiguration conf); Collection<SchemaSource> getNamespaces(QueryExecutionFactory qef); String getNamespaceFromURI(String uri); }### Answer:
@Test public void testGetNamespaces() { assertEquals(13, NamespaceStatistics.createCompleteNSStatisticsAll(null).getNamespaces(qef).size()); assertEquals(0, NamespaceStatistics.createCompleteNSStatisticsKnown(null).getNamespaces(qef).size()); assertEquals(8, NamespaceStatistics.createOntologyNSStatisticsAll(null).getNamespaces(qef).size()); assertEquals(0, NamespaceStatistics.createOntologyNSStatisticsKnown(null).getNamespaces(qef).size()); }
|
### Question:
NamespaceStatistics { public String getNamespaceFromURI(String uri) { String breakChar = "/"; if (uri.contains("#")) { breakChar = "#"; } else { if (uri.substring(6).contains(":")) { breakChar = ":"; } } int pos = Math.min(uri.lastIndexOf(breakChar), uri.length()); return uri.substring(0, pos + 1); } private NamespaceStatistics(Collection<DatasetStatistics> datasetStatisticses, boolean skipUnknownNamespaces, RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createOntologyNSStatisticsAll(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsKnown(RDFUnitConfiguration conf); static NamespaceStatistics createCompleteNSStatisticsAll(RDFUnitConfiguration conf); Collection<SchemaSource> getNamespaces(QueryExecutionFactory qef); String getNamespaceFromURI(String uri); }### Answer:
@Test public void testGetNamespaceFromURI() { Map<String, String> examples = new HashMap<>(); examples.put("http: examples.put("http: examples.put("http: NamespaceStatistics namespaceStatistics = NamespaceStatistics.createCompleteNSStatisticsAll(null); for (Map.Entry<String, String> entry : examples.entrySet()) { String namespace = entry.getValue(); assertEquals("All prefixed should be initialized", namespace, namespaceStatistics.getNamespaceFromURI(entry.getKey())); } }
|
### Question:
LOVEndpoint { public SchemaEntry extractResourceLocation(SchemaEntry entry) { Optional<String> actualResourceUri = Optional.empty(); if (! entry.getVocabularyDefinedBy().equals(entry.getVocabularyNamespace())) { actualResourceUri = getContentLocation(entry.getVocabularyDefinedBy(), GENERALFORMAT, Lists.newArrayList()); } if(! actualResourceUri.isPresent()) { actualResourceUri = getContentLocation(entry.getVocabularyURI(), GENERALFORMAT, Lists.newArrayList()); } if (! actualResourceUri.isPresent() && ! entry.getVocabularyDefinedBy().equals(entry.getVocabularyNamespace())) { actualResourceUri = getContentLocation(entry.getVocabularyDefinedBy(), TEXTHTML, Lists.newArrayList()); } if(! actualResourceUri.isPresent()) { actualResourceUri = getContentLocation(entry.getVocabularyURI(), TEXTHTML, Lists.newArrayList()); } if(! actualResourceUri.isPresent()) { log.info("Could not find resource for " + entry.getVocabularyURI()); return entry; } return new SchemaEntry(entry.getPrefix(), entry.getVocabularyURI(), entry.getVocabularyNamespace(), actualResourceUri.get()); } List<SchemaEntry> getAllLOVEntries(); void writeAllLOVEntriesToFile(String filename); SchemaEntry extractResourceLocation(SchemaEntry entry); static void main(String[] args); }### Answer:
@Ignore @Test public void testExtractResourceLocation() { LOVEndpoint endpoint = new LOVEndpoint(); SchemaEntry entry5 = new SchemaEntry("agr", "https: SchemaEntry result5 = endpoint.extractResourceLocation(entry5); Assert.assertEquals( "https: SchemaEntry entry1 = new SchemaEntry("SAN", "http: SchemaEntry result1 = endpoint.extractResourceLocation(entry1); Assert.assertEquals( entry1.getVocabularyURI().replace("http: SchemaEntry entry9 = new SchemaEntry("medred", "http: SchemaEntry result9 = endpoint.extractResourceLocation(entry9); Assert.assertEquals( "https: SchemaEntry entry8 = new SchemaEntry("comm", "http: SchemaEntry result8 = endpoint.extractResourceLocation(entry8); Assert.assertEquals( "http: SchemaEntry entry3 = new SchemaEntry("af", "http: SchemaEntry result3 = endpoint.extractResourceLocation(entry3); Assert.assertEquals( "http: SchemaEntry entry7 = new SchemaEntry("ssn", "http: SchemaEntry result7 = endpoint.extractResourceLocation(entry7); Assert.assertEquals( "https: SchemaEntry entry6 = new SchemaEntry("agrelon", "http: SchemaEntry result6 = endpoint.extractResourceLocation(entry6); Assert.assertEquals( "https: SchemaEntry entry4 = new SchemaEntry("brk", "http: SchemaEntry result4 = endpoint.extractResourceLocation(entry4); Assert.assertEquals( "https: SchemaEntry entry2 = new SchemaEntry("acco", "http: SchemaEntry result2 = endpoint.extractResourceLocation(entry2); Assert.assertEquals( "http: }
|
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onStart() { mLoginRepository.getUser() .subscribeOn(mSchedulerProvider.io()) .observeOn(mSchedulerProvider.ui()) .subscribe(new OnceObserver<User>() { @Override protected void onResponse(User value) { mView.setUserName(value.getName()); } }); } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onStartFirst() { when(mLoginRepository.getUser()).thenReturn(Observable.<User>empty()); mLoginPresenter.onStart(); verify(mLoginRepository).getUser(); verify(mLoginView, never()).setUserName(anyString()); verify(mLoginView, never()).setPassword(anyString()); }
@Test public void onStartNotFirst() { when(mLoginRepository.getUser()).thenReturn(Observable.just(mUser)); when(mLoginRepository.loginRemote(mUser)).thenReturn(Observable.just(mUser)); mLoginPresenter.onStart(); verify(mLoginRepository).getUser(); verify(mLoginView).setUserName(mUser.getName()); }
|
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void login(User user) { if (user.isUserNameEmpty()) { mView.showUserNameEmpty(); return; } mLoginRepository.loginRemote(user) .subscribeOn(mSchedulerProvider.io()) .doOnNext(new Consumer<User>() { @Override public void accept(User value) throws Exception { value.setLogin(true); mLoginRepository.saveUser(value); } }) .observeOn(mSchedulerProvider.ui()) .subscribe(new OnceLoadingObserver<User>(mView) { @Override protected void onResponse(User value) { mView.openHomePage(); mView.finishActivity(); } }); } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void loginWithError() { String errorMessage = "error"; when(mLoginRepository.loginRemote(mUser)).thenReturn(Observable.<User>error(new MyRuntimeException(errorMessage))); mLoginPresenter.login(mUser); verify(mLoginView).showErrorMessage(errorMessage); verify(mLoginView).hideLoadingDialog(); }
@Test public void loginOk() { when(mLoginRepository.loginRemote(mUser)).thenReturn(Observable.just(mUser)); mLoginPresenter.login(mUser); verify(mLoginRepository).saveUser((User) any()); verify(mLoginView, never()).showErrorMessage(anyString()); verify(mLoginView, never()).showNetWorkError(); verify(mLoginView).hideLoadingDialog(); verify(mLoginView).openHomePage(); verify(mLoginView).finishActivity(); }
@Test public void loginWithUserNameIsEmpty() { mLoginPresenter.login(mEmptyNameUser); verify(mLoginView).showUserNameEmpty(); verify(mLoginRepository, never()).loginRemote(mEmptyNameUser); }
@Test public void loginWithUserNameIsNotEmpty() { when(mLoginRepository.loginRemote(mUser)).thenReturn(Observable.just(mUser)); mLoginPresenter.login(mUser); verify(mLoginView, never()).showUserNameEmpty(); verify(mLoginView).showLoadingDialog(anyBoolean()); verify(mLoginRepository).loginRemote(mUser); }
@Test public void loginWithNetworkError() { when(mLoginRepository.loginRemote(mUser)).thenReturn(Observable.<User>error(new ConnectException())); mLoginPresenter.login(mUser); verify(mLoginView).showNetWorkError(); verify(mLoginView).hideLoadingDialog(); }
|
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onEdtUserNameChanged(String userName) { if (!TextUtil.isEmpty(userName)) { mView.showClearUserNameButton(); } else { mView.hideClearUserNameButton(); } } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onUserNameAfterTextChangedEmpty() { mLoginPresenter.onEdtUserNameChanged(""); verify(mLoginView).hideClearUserNameButton(); }
@Test public void onUserNameAfterTextChangedNotEmpty() { mLoginPresenter.onEdtUserNameChanged("a"); verify(mLoginView).showClearUserNameButton(); }
|
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onBtnClearUserNameClick() { mView.setUserNameEmpty(); } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onClearUserNameBtnClick() { mLoginPresenter.onBtnClearUserNameClick(); verify(mLoginView).setUserNameEmpty(); }
|
### Question:
LoginPresenter extends BaseRxJavaPresenter<LoginContract.View> implements LoginContract.Presenter { @Override public void onBtnShowOrHidePasswordClick(boolean needShow) { if (needShow) { mView.showPassword(); } else { mView.hidePassword(); } } @Inject LoginPresenter(@NonNull LoginRepository loginRepository,
@NonNull ISchedulerProvider schedulerProvider); @Override void onStart(); @Override void onEdtUserNameChanged(String userName); @Override void onBtnClearUserNameClick(); @Override void onBtnShowOrHidePasswordClick(boolean needShow); @Override void login(User user); }### Answer:
@Test public void onShowPasswordButtonClickTrue() { mLoginPresenter.onBtnShowOrHidePasswordClick(true); verify(mLoginView).showPassword(); }
@Test public void onShowPasswordButtonClickFalse() { mLoginPresenter.onBtnShowOrHidePasswordClick(false); verify(mLoginView).hidePassword(); }
|
### Question:
PrometheusPublisher extends Collector implements Collector.Describable, MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override List<MetricFamilySamples> describe(); @Override List<MetricFamilySamples> collect(); @Override void destroy(); }### Answer:
@Test public void testBadPublishAddress() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "a:b:c"); publisher.init(globalRegistry, null, null); }
@Test public void testBadPublishAddress_BadPort() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "localhost:xxxx"); publisher.init(globalRegistry, null, null); }
@Test public void testBadPublishAddress_TooLargePort() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "localhost:9999999"); publisher.init(globalRegistry, null, null); }
|
### Question:
AbstractRestInvocation { protected void findRestOperation(MicroserviceMeta microserviceMeta) { ServicePathManager servicePathManager = ServicePathManager.getServicePathManager(microserviceMeta); if (servicePathManager == null) { LOGGER.error("No schema defined for {}:{}.", microserviceMeta.getAppId(), microserviceMeta.getMicroserviceName()); throw new InvocationException(Status.NOT_FOUND, Status.NOT_FOUND.getReasonPhrase()); } OperationLocator locator = locateOperation(servicePathManager); requestEx.setAttribute(RestConst.PATH_PARAMETERS, locator.getPathVarMap()); this.restOperationMeta = locator.getOperation(); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer:
@Test public void findRestOperationServicePathManagerNull(@Mocked MicroserviceMeta microserviceMeta) { new Expectations(ServicePathManager.class) { { requestEx.getHeader(Const.TARGET_MICROSERVICE); result = "ms"; ServicePathManager.getServicePathManager(microserviceMeta); result = null; } }; expectedException.expect(InvocationException.class); expectedException.expectMessage("CommonExceptionData [message=Not Found]"); restInvocation.findRestOperation(microserviceMeta); }
@Test public void findRestOperationNormal(@Mocked MicroserviceMeta microserviceMeta, @Mocked ServicePathManager servicePathManager, @Mocked OperationLocator locator) { restInvocation = new AbstractRestInvocationForTest() { @Override protected OperationLocator locateOperation(ServicePathManager servicePathManager) { return locator; } }; requestEx = new AbstractHttpServletRequest() { }; restInvocation.requestEx = requestEx; Map<String, String> pathVars = new HashMap<>(); new Expectations(ServicePathManager.class) { { ServicePathManager.getServicePathManager(microserviceMeta); result = servicePathManager; locator.getPathVarMap(); result = pathVars; locator.getOperation(); result = restOperation; } }; restInvocation.findRestOperation(microserviceMeta); Assert.assertSame(restOperation, restInvocation.restOperationMeta); Assert.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS)); }
|
### Question:
AbstractRestInvocation { protected void runOnExecutor() { invocation.onExecuteStart(); invoke(); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer:
@Test public void runOnExecutor() { long time = 123; new MockUp<System>() { @Mock long nanoTime() { return time; } }; Holder<Boolean> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override public void invoke() { result.value = true; } }; restInvocation.createInvocation(); restInvocation.requestEx = requestEx; restInvocation.restOperationMeta = restOperation; restInvocation.runOnExecutor(); Assert.assertTrue(result.value); Assert.assertSame(invocation, restInvocation.invocation); assertEquals(time, invocation.getInvocationStageTrace().getStartExecution()); }
|
### Question:
EnvAdapterManager extends RegisterManager<String, EnvAdapter> { public void processMicroserviceWithAdapters(Microservice microservice) { getObjMap().forEach((name, adapter) -> { LOGGER.info("Start process microservice with adapter {}", name); adapter.beforeRegisterService(microservice); }); } EnvAdapterManager(); void processMicroserviceWithAdapters(Microservice microservice); void processSchemaWithAdapters(String schemaId, String content); void processInstanceWithAdapters(MicroserviceInstance instance); static final EnvAdapterManager INSTANCE; }### Answer:
@Test public void testProcessMicroservice() { Microservice microservice = new Microservice(); manager.processMicroserviceWithAdapters(microservice); assertEquals("order=0", microservice.getProperties().get("cas_env_one")); assertEquals("order=0", microservice.getProperties().get("cas_env_two")); assertNull(microservice.getProperties().get("default-env-adapter")); }
|
### Question:
AbstractRestInvocation { protected void doInvoke() throws Throwable { invocation.getInvocationStageTrace().startHandlersRequest(); invocation.next(resp -> sendResponseQuietly(resp)); } AbstractRestInvocation(); void setHttpServerFilters(List<HttpServerFilter> httpServerFilters); String getContext(String key); void invoke(); void sendFailResponse(Throwable throwable); static final String UNKNOWN_OPERATION_ID; }### Answer:
@Test public void doInvoke(@Mocked Endpoint endpoint, @Mocked OperationMeta operationMeta, @Mocked Object[] swaggerArguments, @Mocked SchemaMeta schemaMeta) throws Throwable { Response response = Response.ok("ok"); Handler handler = (invocation, asyncResp) -> asyncResp.complete(response); List<Handler> handlerChain = Arrays.asList(handler); Deencapsulation.setField(invocation, "handlerList", handlerChain); Holder<Response> result = new Holder<>(); restInvocation = new AbstractRestInvocationForTest() { @Override protected void sendResponse(Response response) { result.value = response; } }; restInvocation.invocation = invocation; restInvocation.doInvoke(); Assert.assertSame(response, result.value); assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartHandlersRequest()); assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishHandlersResponse()); }
|
### Question:
ClassPathStaticResourceHandler extends StaticResourceHandler { protected Part findResource(String path) throws IOException { URL url = this.getClass().getClassLoader().getResource(path); if (url == null) { return null; } return new InputStreamPart(null, url.openStream()).setSubmittedFileName(path); } }### Answer:
@Test public void readContentFailed() throws IOException { new Expectations(handler) { { handler.findResource(anyString); result = new RuntimeExceptionWithoutStackTrace("read content failed."); } }; try (LogCollector logCollector = new LogCollector()) { Response response = handler.handle("index.html"); Assert.assertEquals("failed to process static resource, path=web-root/index.html", logCollector.getLastEvents().getMessage()); InvocationException invocationException = response.getResult(); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR, invocationException.getStatus()); Assert.assertEquals("failed to process static resource.", ((CommonExceptionData) invocationException.getErrorData()).getMessage()); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatusCode()); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR.getReasonPhrase(), response.getReasonPhrase()); } }
|
### Question:
ServicePathManager { public static ServicePathManager getServicePathManager(MicroserviceMeta microserviceMeta) { return microserviceMeta.getExtData(REST_PATH_MANAGER); } ServicePathManager(MicroserviceMeta microserviceMeta); static ServicePathManager getServicePathManager(MicroserviceMeta microserviceMeta); OperationLocator consumerLocateOperation(String path, String httpMethod); OperationLocator producerLocateOperation(String path, String httpMethod); void addResource(RestOperationMeta swaggerRestOperation); void sortPath(); void buildProducerPaths(); }### Answer:
@Test public void testBuildProducerPathsNoPrefix() { SCBEngine scbEngine = SCBBootstrap.createSCBEngineForTest() .addProducerMeta("sid1", new TestPathSchema()) .run(); ServicePathManager spm = ServicePathManager.getServicePathManager(scbEngine.getProducerMicroserviceMeta()); Assert.assertSame(spm.producerPaths, spm.swaggerPaths); scbEngine.destroy(); }
|
### Question:
MicroservicePaths { public Map<String, OperationGroup> getStaticPathOperationMap() { return staticPathOperations; } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void staticGroup() { RestOperationMeta meta = paths.getStaticPathOperationMap().get("/static/").findValue("POST"); Assert.assertSame("postStatic", meta.getOperationMeta().getOperationId()); meta = paths.getStaticPathOperationMap().get("/static/").findValue("GET"); Assert.assertSame("getStatic", meta.getOperationMeta().getOperationId()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.