Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: AgentManager { @PreDestroy public void cleanup() throws ADKException { agent.shutdown(ADKFlags.PROV_NONE); } @PostConstruct void postConstruct(); void setup(); @PreDestroy void cleanup(); void setSubscribeTypeList(List<String> subscribeTypeList); List<String> getSubscribeTypeList(); void setSubscriberZoneName(String subscriberZoneName); String getSubscriberZoneName(); void setAgent(SifAgent agent); SifAgent getAgent(); String getLogPath(); void setLogPath(String logPath); String getAdkLogFile(); void setAdkLogFile(String adkLogFile); List<ElementDef> getSubscribeList(); void setSubscribeList(List<ElementDef> subscribeList); }### Answer: @Test public void shouldShutdownAgentOnCleanup() throws ADKException { agentManager.cleanup(); Mockito.verify(mockAgent, Mockito.times(1)).shutdown(Mockito.eq(ADKFlags.PROV_NONE)); }
### Question: StudentPersonalTranslationTask extends AbstractTranslationTask<StudentPersonal, StudentEntity> { private List<String> getHomeLanguages(LanguageList languageList) { Language[] languages = languageList == null ? null : languageList.getLanguages(); if (languages == null) { return null; } LanguageList homeList = new LanguageList(); for (Language language : languages) { if (language.getLanguageType() != null && LanguageType.HOME.valueEquals(language.getLanguageType())) { homeList.add(language); } } return homeList.size() == 0 ? null : languageListConverter.convert(homeList); } StudentPersonalTranslationTask(); @Override List<StudentEntity> doTranslate(StudentPersonal sifData, String zoneId); }### Answer: @Test public void testLanguages() throws SifTranslationException { StudentPersonal info = new StudentPersonal(); Demographics demographics = new Demographics(); LanguageList languageList = new LanguageList(); languageList.addLanguage(LanguageCode.ENGLISH); languageList.addLanguage(LanguageCode.CHINESE); demographics.setLanguageList(languageList); info.setDemographics(demographics); Mockito.when(mockLanguageListConverter.convert(Mockito.any(LanguageList.class))).thenReturn(Arrays.asList("English", "Chinese")); List<StudentEntity> result = translator.translate(info, null); Assert.assertEquals(1, result.size()); StudentEntity entity = result.get(0); List<String> list = entity.getLanguages(); Assert.assertEquals(2, list.size()); Assert.assertEquals("language[0] is expected to be 'English'", "English", list.get(0)); Assert.assertEquals("language[1] is expected to be 'Chinese'", "Chinese", list.get(1)); list = entity.getHomeLanguages(); Assert.assertNull("Home Languages was not null", list); }
### Question: SifTranslationManager { public List<SliEntity> translate(SIFDataObject sifData, String zoneId) { List<SliEntity> entities = new ArrayList<SliEntity>(); List<TranslationTask> translationTasks = translationMap.get(sifData.getObjectType().toString()); if (translationTasks == null) { LOG.error("No TranslationTask found for sif type: " + sifData.getObjectType()); return entities; } for (TranslationTask translationTask : translationTasks) { try { entities.addAll(translationTask.translate(sifData, zoneId)); } catch (SifTranslationException e) { LOG.error("Sif translation exception: ", e); } } return entities; } void setTranslationMap(Map<String, List<TranslationTask>> translationMap); List<SliEntity> translate(SIFDataObject sifData, String zoneId); }### Answer: @Test public void shouldCreateOneToOneTranslatedEntities() { List<SliEntity> sliEntities = sifTranslationManager.translate(sifB, "zoneId"); Assert.assertEquals("Should translate to one sli entity", 1, sliEntities.size()); Assert.assertEquals("First translated entity not of correct", sliZ, sliEntities.get(0)); } @Test public void shouldCreateOneToManyTranslatedEntities() { List<SliEntity> sliEntities = sifTranslationManager.translate(sifA, "zoneId"); Assert.assertEquals("Should translate to two sli entities", 2, sliEntities.size()); Assert.assertEquals("First translated entity not of correct", sliX, sliEntities.get(0)); Assert.assertEquals("First translated entity not of correct", sliY, sliEntities.get(1)); } @Test public void shouldHandleSifTranslationExceptions() throws SifTranslationException { Mockito.when(mockTranslationBtoZ.translate(Mockito.eq(sifB), Mockito.anyString())).thenThrow( new SifTranslationException("test throw")); sifTranslationManager.translate(sifA, "zoneId"); }
### Question: PublishZoneConfigurator implements ZoneConfigurator { @Override public void configure(Zone[] allZones) { for (Zone zone : allZones) { try { LOG.info("- Connecting to zone \"" + zone.getZoneId() + "\" at " + zone.getZoneUrl()); zone.connect(ADKFlags.PROV_REGISTER \| ADKFlags.PROV_PROVIDE); } catch (ADKException ex) { LOG.error(" " + ex.getMessage(), ex); } } } @Override void configure(Zone[] allZones); }### Answer: @Test public void testConfigure() throws ADKException { Zone[] zones = {zone1, zone2, zone3}; publishZoneConfigurator.configure(zones); Mockito.verify(zone1, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone2, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone3, Mockito.times(1)).connect(Mockito.anyInt()); Assert.assertTrue(publishZoneConfigurator instanceof ZoneConfigurator); }
### Question: SubscribeZoneConfigurator implements ZoneConfigurator { @Override public void configure(Zone[] allZones) { for (Zone zone : allZones) { try { LOG.info("- Connecting to zone \"" + zone.getZoneId() + "\" at " + zone.getZoneUrl()); zone.connect(ADKFlags.PROV_REGISTER \| ADKFlags.PROV_SUBSCRIBE); } catch (ADKException ex) { LOG.error(" " + ex.getMessage(), ex); } } } @Override void configure(Zone[] allZones); }### Answer: @Test public void testConfigure() throws ADKException { Zone[] zones = {zone1, zone2, zone3}; subscribeZoneConfigurator.configure(zones); Mockito.verify(zone1, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone2, Mockito.times(1)).connect(Mockito.anyInt()); Mockito.verify(zone3, Mockito.times(1)).connect(Mockito.anyInt()); Assert.assertTrue(subscribeZoneConfigurator instanceof ZoneConfigurator); }
### Question: SliEntity { public Map<String, Object> createBody() { Map<String, Object> body = null; try { body = MAPPER. readValue(this.json(), new TypeReference<Map<String, Object>>() { }); clearNullValueKeys(body); } catch (JsonParseException e) { LOG.error("Entity map conversion error: ", e); } catch (JsonMappingException e) { LOG.error("Entity map conversion error: ", e); } catch (IOException e) { LOG.error("Entity map conversion error: ", e); } return body; } SliEntity(); abstract String entityType(); GenericEntity createGenericEntity(); Map<String, Object> createBody(); JsonNode json(); @JsonIgnore boolean isCreatedByOthers(); @JsonIgnore String getCreatorRefId(); @JsonIgnore void setCreatorRefId(String creatorRefId); @JsonIgnore String getZoneId(); @JsonIgnore void setZoneId(String zoneId); @JsonIgnore String getOtherSifRefId(); @JsonIgnore void setOtherSifRefId(String otherSifRefId); @JsonIgnore boolean hasOtherSifRefId(); @Override String toString(); }### Answer: @Test public void shouldTransformConcreteBodyToMap() { testSliEntity = new TestSliEntity(); Map<String, Object> body = testSliEntity.createBody(); Assert.assertEquals("Body should contain 2 elements", 2, body.size()); Assert.assertEquals("Incorrect map element", "1", body.get("fieldOne")); @SuppressWarnings("unchecked") Map<String, Object> subObjectMap = (Map<String, Object>) body.get("testSubObject"); Assert.assertNotNull("SubObject map null", subObjectMap); Assert.assertEquals("subObject should contain 2 elements", 2, subObjectMap.size()); Assert.assertEquals("Incorrect map element", "A", subObjectMap.get("subFieldA")); Assert.assertEquals("Incorrect map element", "B", subObjectMap.get("subFieldB")); }
### Question: SliEntity { public GenericEntity createGenericEntity() { GenericEntity entity = new GenericEntity(entityType(), createBody()); return entity; } SliEntity(); abstract String entityType(); GenericEntity createGenericEntity(); Map<String, Object> createBody(); JsonNode json(); @JsonIgnore boolean isCreatedByOthers(); @JsonIgnore String getCreatorRefId(); @JsonIgnore void setCreatorRefId(String creatorRefId); @JsonIgnore String getZoneId(); @JsonIgnore void setZoneId(String zoneId); @JsonIgnore String getOtherSifRefId(); @JsonIgnore void setOtherSifRefId(String otherSifRefId); @JsonIgnore boolean hasOtherSifRefId(); @Override String toString(); }### Answer: @Test public void shouldCreateGenericEntity() { testSliEntity = new TestSliEntity(); GenericEntity entity = testSliEntity.createGenericEntity(); Assert.assertNotNull("GenericEntity null", entity); Assert.assertNotNull("Entity body null", entity.getData()); Assert.assertEquals("Incorrect entity type", "TestEntity", entity.getEntityType()); }
### Question: YesNoUnknownConverter { public Boolean convert(String value) { return value == null ? null : BOOLEAN_MAP.get(value); } Boolean convert(String value); }### Answer: @Test public void testNullObject() { Boolean result = converter.convert(null); Assert.assertNull("Race list should be null", result); } @Test public void testYes() { Boolean result = converter.convert("Yes"); Assert.assertEquals(Boolean.TRUE, result); } @Test public void testNo() { Boolean result = converter.convert("No"); Assert.assertEquals(Boolean.FALSE, result); } @Test public void testUnknown() { Boolean result = converter.convert("Unknown"); Assert.assertNull(result); }
### Question: YesNoConverter { public Boolean convert(YesNo value) { return value == null ? null : BOOLEAN_MAP.get(value); } Boolean convert(YesNo value); }### Answer: @Test public void testNullObject() { Boolean result = converter.convert(null); Assert.assertNull("Result should be null", result); } @Test public void testYes() { Boolean result = converter.convert(YesNo.YES); Assert.assertEquals(Boolean.TRUE, result); } @Test public void testNo() { Boolean result = converter.convert(YesNo.NO); Assert.assertEquals(Boolean.FALSE, result); } @Test public void testUnknown() { Boolean result = converter.convert(YesNo.wrap("Unknown")); Assert.assertNull(result); }
### Question: DateConverter { public String convert(Calendar date) { if (date == null) { return null; } return dateFormat.format(date.getTime()); } String convert(Calendar date); }### Answer: @Test public void shouldConvertWithCorrectFormat() { Calendar date = new GregorianCalendar(2004, Calendar.FEBRUARY, 29); String result = converter.convert(date); Assert.assertEquals("2004-02-29", result); } @Test public void shouldHandleNullDate() { String result = converter.convert(null); Assert.assertNull(result); }
### Question: SchoolFocusConverter { public String convert(SchoolFocusList schoolFocusList) { if (schoolFocusList == null \|\| schoolFocusList.getSchoolFocuses().length == 0) { return null; } SchoolFocus[] schoolFocus = schoolFocusList.getSchoolFocuses(); String result = SCHOOL_FOCUS_MAP.get(schoolFocus[0].getValue()); if (result != null) { return result; } return NOT_SUPPORTED; } String convert(SchoolFocusList schoolFocusList); }### Answer: @Test public void testNullList() { String result = converter.convert(null); Assert.assertNull("school type should be null", result); } @Test public void testEmptyList() { SchoolFocusList list = new SchoolFocusList(); String result = converter.convert(list); Assert.assertNull("school type should be null", result); } @Test public void testEmptySchoolFocus() { SchoolFocusList list = new SchoolFocusList(new SchoolFocus()); String result = converter.convert(list); Assert.assertEquals("Not Supported", result); }
### Question: EntityExtractor { public void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter) { if (archiveFile != null) { write(entity, archiveFile, new CollectionWrittenRecord(collectionName), filter); } } void extractEntities(ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void extractEntity(Entity entity, ExtractFile archiveFile, String collectionName); void extractEmbeddedEntities(Entity entity, ExtractFile archiveFile, String collectionName, Predicate<Entity> filter); void write(Entity entity, ExtractFile archiveFile, CollectionWrittenRecord collectionRecord, Predicate<Entity> filter); void setEntityRepository(Repository<Entity> entityRepository); void setExtractionQuery(NeutralQuery extractionQuery); void setWriter(EntityWriterManager writer); }### Answer: @Test public void testExtractEntity() throws IOException { extractor.extractEntity(Mockito.mock(Entity.class), Mockito.mock(ExtractFile.class), "BLOOP"); Mockito.verify(writer, Mockito.times(1)).write(Mockito.any(Entity.class), Mockito.any(ExtractFile.class)); }
### Question: EmailListConverter { public List<ElectronicMail> convert(EmailList list) { if (list == null) { return null; } List<ElectronicMail> result = new ArrayList<ElectronicMail>(); for (Email sifEmail : list) { ElectronicMail sliEmail = new ElectronicMail(); sliEmail.setEmailAddress(sifEmail.getValue()); result.add(sliEmail); } return result; } List<ElectronicMail> convert(EmailList list); }### Answer: @Test public void testNullObject() { List<ElectronicMail> result = converter.convert(null); Assert.assertNull("Address list should be null", result); } @Test public void testEmptyList() { EmailList list = new EmailList(); List<ElectronicMail> result = converter.convert(list); Assert.assertEquals(0, result.size()); } @Test public void testEmptyEmail() { EmailList list = new EmailList(); list.add(new Email()); List<ElectronicMail> result = converter.convert(list); Assert.assertEquals(1, result.size()); ElectronicMail sliEmail = result.get(0); Assert.assertNull(sliEmail.getEmailAddressType()); Assert.assertNull(sliEmail.getEmailAddress()); } @Test public void testMappings() { EmailList emails = createEmailList(); List<ElectronicMail> result = converter.convert(emails); Assert.assertEquals("Should map 5 emails", 5, result.size()); for (int i = 0; i < 5; i++) { Assert.assertNotNull(result.get(i)); Assert.assertEquals(result.get(i).getEmailAddress(), "email" + i); Assert.assertEquals(result.get(i).getEmailAddressType(), null); } }
### Question: TreatmentApplicator implements Treatment { @Override public Entity apply(Entity entity) { Entity treated = entity; for (Treatment treatment : treatments) { treated = treatment.apply(treated); } return treated; } @Override Entity apply(Entity entity); List<Treatment> getTreatments(); void setTreatments(List<Treatment> treatments); }### Answer: @Test public void testApplyAll() { Entity student = Mockito.mock(Entity.class); applicator.apply(student); Mockito.verify(treatment1,Mockito.atLeast(1)).apply(Mockito.any(Entity.class)); Mockito.verify(treatment2,Mockito.atLeast(1)).apply(Mockito.any(Entity.class)); }
### Question: AttendanceTreatment implements Treatment { @Override public Entity apply(Entity entity) { if (entity.getBody().containsKey("schoolYearAttendance")) { LOG.debug("Treatment has already been applied to attendance entity: {}", new Object[] { entity.getEntityId() }); return entity; } Map<String,Object> treated = AttendanceStrategyHelper.wrap(entity.getBody()); entity.getBody().clear(); entity.getBody().putAll(treated); return entity; } @Override Entity apply(Entity entity); }### Answer: @Test public void testApply() { Map<String, Object> body = new HashMap<String, Object>(); body.put("schoolYear", "schoolYear"); List<Map<String,Object>> attendanceEvent = new ArrayList<Map<String,Object>>(); body.put("attendanceEvent", attendanceEvent); Entity entity = new BulkExtractEntity(body, "student"); Entity treated = treat.apply(entity); Assert.assertNotNull(treated.getBody().get("schoolYearAttendance")); List<Map<String, Object>> attendances = new ArrayList<Map<String, Object>>(); Map<String, Object> schoolYearAttendance = new HashMap<String, Object>(); attendances = (List<Map<String, Object>>) treated.getBody().get("schoolYearAttendance"); schoolYearAttendance = attendances.get(0); Assert.assertNotNull(schoolYearAttendance.get("schoolYear")); Assert.assertNotNull(schoolYearAttendance.get("attendanceEvent")); Assert.assertEquals("schoolYear", schoolYearAttendance.get("schoolYear")); Assert.assertNotNull(schoolYearAttendance.get("attendanceEvent")); } @Test public void testDuplicateApplication() { Map<String, Object> body = new HashMap<String, Object>(); body.put("schoolYearAttendance", new Object()); Entity entity = new BulkExtractEntity(body, "student"); Entity treated = treat.apply(entity); Assert.assertEquals(entity, treated); }
### Question: RaceListConverter { public List<String> convert(RaceList raceList) { if (raceList == null) { return null; } return toSliRaceList(raceList.getRaces()); } List<String> convert(RaceList raceList); }### Answer: @Test public void testNullObject() { List<String> result = converter.convert(null); Assert.assertNull("Race list should be null", result); } @Test public void testEmptyList() { RaceList list = new RaceList(); List<String> result = converter.convert(list); Assert.assertEquals(0, result.size()); } @Test public void testConversion() { for (RaceType rt : map.keySet()) { RaceList rl = new RaceList(); Race r = new Race(); r.setCode(rt); rl.add(r); List<String> convertedList = converter.convert(rl); Assert.assertEquals(1, convertedList.size()); Assert.assertEquals(map.get(rt), convertedList.get(0)); } } @Test public void testListConversion() { RaceList rl = new RaceList(); for (RaceType rt : map.keySet()) { Race r = new Race(); r.setCode(rt); rl.add(r); } List<String> convertedList = converter.convert(rl); List<String> expectedList = new ArrayList<String>(); expectedList.addAll(map.values()); Collections.sort(convertedList); Collections.sort(expectedList); Assert.assertEquals(expectedList.size(), convertedList.size()); for (int i = 0; i < expectedList.size(); i++) { Assert.assertEquals(expectedList.get(i), convertedList.get(i)); } }
### Question: EnglishProficiencyConverter { public String convert(EnglishProficiency ep) { if (ep == null) { return null; } EnglishProficiencyCode code = EnglishProficiencyCode.wrap(ep.getCode()); return ENGLISH_PROFICIENCY_MAP.get(code); } String convert(EnglishProficiency ep); }### Answer: @Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("English Proficiency should be null", result); } @Test public void testNativeEnglish() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.NATIVE_ENGLISH); String result = converter.convert(ep); Assert.assertEquals("NotLimited", result); } @Test public void testFluentEnglish() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.FLUENT_ENGLISH); String result = converter.convert(ep); Assert.assertEquals("NotLimited", result); } @Test public void testNonEnglishSpeaking() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.NON_ENGLISH_SPEAKING); String result = converter.convert(ep); Assert.assertEquals("Limited", result); } @Test public void testRedesignatedAsFluent() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.REDESIGNATED_AS_FLUENT); String result = converter.convert(ep); Assert.assertEquals("NotLimited", result); } @Test public void testLimitedEnglish() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.LIMITED_ENGLISH); String result = converter.convert(ep); Assert.assertEquals("Limited", result); } @Test public void testUnknown() { EnglishProficiency ep = new EnglishProficiency(); ep.setCode(EnglishProficiencyCode.STATUS_UNKNOWN); String result = converter.convert(ep); Assert.assertNull(result); }
### Question: SchoolYearConverter { public String convert(Integer schoolYear) { if (schoolYear == null) { return null; } Integer priorSchoolYear = schoolYear - 1; return priorSchoolYear.toString() + "-" + schoolYear.toString(); } String convert(Integer schoolYear); }### Answer: @Test public void testNullList() { String result = converter.convert(null); Assert.assertNull("school year should be null", result); } @Test public void test() { Assert.assertEquals(converter.convert(2011), "2010-2011"); Assert.assertEquals(converter.convert(2013), "2012-2013"); }
### Question: GenderConverter { public String convert(String gender) { return GENDER_TYPE_MAP.get(gender); } String convert(String gender); }### Answer: @Test public void testNullObject() { String result = converter.convert(null); Assert.assertNull("Race list should be null", result); } @Test public void testMale() { String result = converter.convert("M"); Assert.assertEquals("Male", result); } @Test public void testFemale() { String result = converter.convert("F"); Assert.assertEquals("Female", result); } @Test public void testUnknown() { String result = converter.convert("U"); Assert.assertNull(result); }
### Question: OperationalStatusConverter { public String convert(OperationalStatus operationalStatus) { if (operationalStatus == null \|\| operationalStatus.getValue() == null \|\| operationalStatus.getValue().isEmpty()) { return null; } return OPERATIONAL_STATUS_MAP.get(operationalStatus); } String convert(OperationalStatus operationalStatus); }### Answer: @Test public void testNull() { String result = converter.convert(null); Assert.assertNull("Operational status should be null", result); } @Test public void testEmpty() { OperationalStatus status = OperationalStatus.wrap(""); String result = converter.convert(status); Assert.assertNull("Operational status should be null", result); } @Test public void testMappings() { map.clear(); map.put(OperationalStatus.AGENCY_CHANGED, "Changed Agency"); map.put(OperationalStatus.AGENCY_CLOSED, "Closed"); map.put(OperationalStatus.AGENCY_FUTURE, "Future"); map.put(OperationalStatus.AGENCY_INACTIVE, "Inactive"); map.put(OperationalStatus.AGENCY_NEW, "New"); map.put(OperationalStatus.AGENCY_OPEN, "Active"); map.put(OperationalStatus.CHANGED_BOUNDARY, null); map.put(OperationalStatus.SCHOOL_CLOSED, "Closed"); map.put(OperationalStatus.SCHOOL_FUTURE, "Future"); map.put(OperationalStatus.SCHOOL_INACTIVE, "Inactive"); map.put(OperationalStatus.SCHOOL_NEW, "New"); map.put(OperationalStatus.SCHOOL_OPEN, "Active"); for (OperationalStatus status : map.keySet()) { String expected = map.get(status); String result = converter.convert(status); Assert.assertEquals(expected, result); } String result = converter.convert(OperationalStatus.wrap("something else")); Assert.assertNull(result); }
### Question: SchoolLevelTypeConverter { public String convert(SchoolLevelType schoolLevelType) { if (schoolLevelType == null) { return null; } return SCHOOL_LEVEL_TYPE_MAP.get(schoolLevelType); } String convert(SchoolLevelType schoolLevelType); List<String> convertAsList(SchoolLevelType schoolLevelType); }### Answer: @Test public void testNull() { String result = converter.convert(null); Assert.assertNull("School category should be null", result); } @Test public void testEmpty() { SchoolLevelType type = SchoolLevelType.wrap(""); String result = converter.convert(type); Assert.assertNull(result); }
### Question: SchoolLevelTypeConverter { public List<String> convertAsList(SchoolLevelType schoolLevelType) { if (schoolLevelType == null) { return null; } ArrayList<String> list = new ArrayList<String>(); String category = SCHOOL_LEVEL_TYPE_MAP.get(schoolLevelType); if (category != null) { list.add(category); } return list; } String convert(SchoolLevelType schoolLevelType); List<String> convertAsList(SchoolLevelType schoolLevelType); }### Answer: @Test public void testListNull() { List<String> result = converter.convertAsList(null); Assert.assertNull("School category should be null", result); } @Test public void testListEmpty() { SchoolLevelType type = SchoolLevelType.wrap(""); List<String> result = converter.convertAsList(type); Assert.assertEquals(0, result.size()); }
### Question: MockZis { public String createAckString() { SIF_Message message = new SIF_Message(); SIF_Ack ack = message.ackStatus(0); return sifElementToString(ack); } void parseSIFMessage(String sifString); void broadcastMessage(String xmlMessage); @PostConstruct void setup(); String createAckString(); void getAgentUrls(Set<String> agentCallbackUrls); Set<String> getAgentUrls(); }### Answer: @Test public void shouldCreateAckMessages() throws ADKException, IOException { String ackString = mockZis.createAckString(); SIFParser parser = SIFParser.newInstance(); SIFElement sifElem = parser.parse(ackString); Assert.assertTrue("Should create a SIF message", (sifElem instanceof SIF_Ack)); }
### Question: DatelessExtractVerifier implements ExtractVerifier { @Override public boolean shouldExtract(Entity entity, DateTime upToDate) { return true; } @Override boolean shouldExtract(Entity entity, DateTime upToDate); }### Answer: @Test public void testshouldExtract() { Entity student = Mockito.mock(Entity.class); Mockito.when(student.getType()).thenReturn(EntityNames.STUDENT); Assert.assertTrue(datelessExtractVerifier.shouldExtract(student, DateTime.parse("2011-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(datelessExtractVerifier.shouldExtract(student, null)); }
### Question: CharacterBlacklistStrategy extends AbstractBlacklistStrategy { @Override public boolean isValid(String context, String input) { if (input == null) { return false; } for (char c : input.toCharArray()) { if (characterSet.contains(c)) { return false; } } return true; } CharacterBlacklistStrategy(); @Override boolean isValid(String context, String input); }### Answer: @Test public void testIsValid() { AbstractBlacklistStrategy strategy = new CharacterBlacklistStrategy(); List<String> badStringList = createBadStringList(); List<Character> badCharList = createCharacterListFromStringList(badStringList); strategy.setInputCollection(badStringList); strategy.init(); runTestLoop(badCharList, strategy, false); List<String> goodStringList = createGoodStringList(); List<Character> goodCharList = createCharacterListFromStringList(goodStringList); runTestLoop(goodCharList, strategy, true); }
### Question: RegexBlacklistStrategy extends AbstractBlacklistStrategy { @Override public boolean isValid(String context, String input) { if (input == null) { return false; } for (Pattern pattern : patternList) { Matcher matcher = pattern.matcher(input); if (matcher.find()) { return false; } } return true; } RegexBlacklistStrategy(); @Override boolean isValid(String context, String input); }### Answer: @Test public void testIsValid() { AbstractBlacklistStrategy strategy = new RegexBlacklistStrategy(); List<String> badRegexStringList = createBadRegexStringList(); strategy.setInputCollection(badRegexStringList); strategy.init(); List<String> badStringList = createBadStringList(); runTestLoop(badStringList, strategy, false); List<String> goodStringList = createGoodStringList(); runTestLoop(goodStringList, strategy, true); }
### Question: SelfReferenceExtractor { public String getSelfReferenceFields(Entity entity) { String selfReferenceField = null; NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { selfReferenceField = getSelfReferenceFields(schema, ""); } } return selfReferenceField; } String getSelfReferenceFields(Entity entity); Map<String, NeutralSchema> getSchemaFields(NeutralSchema schema); }### Answer: @Test public void testGetSelfReferenceFields() { Entity srEntity = Mockito.mock(Entity.class); Mockito.when(srEntity.getType()).thenReturn(SELF_REFERENCE_COLLECTION); Entity nonSrEntity = Mockito.mock(Entity.class); Mockito.when(nonSrEntity.getType()).thenReturn(NON_SELF_REFERENCE_COLLECTION); String selfReferenceField = selfReferenceExtractor.getSelfReferenceFields(srEntity); Assert.assertEquals("field2", selfReferenceField); selfReferenceField = selfReferenceExtractor.getSelfReferenceFields(nonSrEntity); Assert.assertEquals(null, selfReferenceField); }
### Question: TokenSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { return addError(this.matchesToken(entity), fieldName, entity, getQuotedTokens(), ErrorType.ENUMERATION_MISMATCH, errors); } TokenSchema(); TokenSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); @Override Object convert(Object value); static final String TOKENS; }### Answer: @Test public void testTokenValidation() throws IllegalArgumentException { List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); schema.getProperties().put(TokenSchema.TOKENS, tokens); String tokenEntity = "validToken"; assertTrue("Token entity validation failed", schema.validate(tokenEntity)); } @Test public void testTokenValidationFailure() throws IllegalArgumentException { List<String> tokens = new ArrayList<String>(); tokens.add("validToken"); schema.getProperties().put(TokenSchema.TOKENS, tokens); String tokenEntity = "invalidToken"; assertFalse("Expected TokenSchema invalid token validation failure did not succeed", schema.validate(tokenEntity)); } @Test public void testValidationOfBooleanFailure() { Boolean booleanEntity = true; assertFalse("Expected TokenSchema boolean validation failure did not succeed", schema.validate(booleanEntity)); } @Test public void testValidationOfIntegerFailure() { Integer integerEntity = 0; assertFalse("Expected TokenSchema integer validation failure did not succeed", schema.validate(integerEntity)); } @Test public void testValidationOfFloatFailure() { Float floatEntity = new Float(0); assertFalse("Expected TokenSchema float validation failure did not succeed", schema.validate(floatEntity)); }
### Question: EntityDateHelper { public static String retrieveDate(Entity entity) { return (String) entity.getBody().get(EntityDates.ENTITY_DATE_FIELDS.get(entity.getType())); } static boolean shouldExtract(Entity entity, DateTime upToDate); static String retrieveDate(Entity entity); static boolean isPastOrCurrentDate(String entityDate, DateTime upToDate, String type); }### Answer: @Test public void testRetrieveDate() { Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "01-01-01"); Entity studentProgramAssociation = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); Assert.assertEquals("01-01-01", EntityDateHelper.retrieveDate(studentProgramAssociation)); }
### Question: LongSchema extends PrimitiveNumericSchema<Long> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).longValue(); } else if (value instanceof Long) { return (Long) value; } else if (value instanceof String) { try { return Long.parseLong((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a long").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a long"); } LongSchema(); @Override Object convert(Object value); }### Answer: @Test public void testConvert() throws Exception { long value = 10L; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Long); Long convertedInput = (Long) convertedValue; assertTrue(convertedInput.longValue() == value); } @Test(expected = IllegalArgumentException.class) public void testBadConvert() { this.schema.convert("INVALID INPUT"); } @Test public void testNonConvert() { Object convertedValue = this.schema.convert(12345L); assertTrue(convertedValue instanceof Long); } @Test public void testLongConverter() { long data = 12345L; int intData = (int) data; assertTrue("Failure returning same object", this.schema.convert(data).equals(data)); assertTrue("Failure parsing long from integer", this.schema.convert(intData).equals(data)); assertTrue("Failure parsing long data", this.schema.convert("" + data).equals(data)); } @Test(expected = IllegalArgumentException.class) public void testInvalidStringThrowsException() throws IllegalArgumentException { this.schema.convert("INVALID INPUT"); } @Test(expected = IllegalArgumentException.class) public void testUnsupportedObjectTypeThrowsException() throws IllegalArgumentException { this.schema.convert(new Object()); }
### Question: DateTimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDateTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 DateTime", ErrorType.INVALID_DATE_FORMAT, errors); } DateTimeSchema(); DateTimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }### Answer: @Test public void testDateTimeStringValidation() throws IllegalArgumentException { String dateTimeString = "2012-01-01T12:00:00-05:00"; assertTrue("DateTime entity validation failed", schema.validate(dateTimeString)); } @Test public void testDateTimeValidation() { Calendar calendar = Calendar.getInstance(); String dateTimeString = javax.xml.bind.DatatypeConverter.printTime(calendar); assertTrue("DateTime entity validation failed", schema.validate(dateTimeString)); } @Test public void testValidationOfStringFailure() { String stringEntity = ""; assertFalse("Expected DateTimeSchema string validation failure did not succeed", schema.validate(stringEntity)); }
### Question: NaturalKeyExtractor implements INaturalKeyExtractor { @Override public Map<String, Boolean> getNaturalKeyFields(Entity entity) throws NoNaturalKeysDefinedException { Map<String, Boolean> naturalKeyFields = null; NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { if (appInfo.applyNaturalKeys()) { naturalKeyFields = new HashMap<String, Boolean>(); getNaturalKeyFields(naturalKeyFields, schema, false, ""); if (naturalKeyFields.isEmpty()) { LOG.error("Failed to find natural key definitions for the " + entity.getType() + " entity"); throw new NoNaturalKeysDefinedException(entity.getType()); } } } } return naturalKeyFields; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }### Answer: @Test public void testGetNaturalKeyFields() throws NoNaturalKeysDefinedException { Entity e = setup(); Map<String, Boolean> naturalKeyFields = naturalKeyExtractor.getNaturalKeyFields(e); Assert.assertEquals(1, naturalKeyFields.size()); Assert.assertEquals("someField", naturalKeyFields.entrySet().iterator().next().getKey()); Mockito.verify(entitySchemaRegistry, Mockito.times(1)).getSchema(Mockito.anyString()); }
### Question: NaturalKeyExtractor implements INaturalKeyExtractor { @Override public NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity) throws NoNaturalKeysDefinedException { Map<String, String> map = getNaturalKeys(entity); if (map == null) { NaturalKeyDescriptor naturalKeyDescriptor = new NaturalKeyDescriptor(); naturalKeyDescriptor.setNaturalKeysNotNeeded(true); return naturalKeyDescriptor; } String entityType = getCollectionName(entity); String tenantId = TenantContext.getTenantId(); String parentId = retrieveParentId(entity); NaturalKeyDescriptor naturalKeyDescriptor = new NaturalKeyDescriptor(map, tenantId, entityType, parentId); return naturalKeyDescriptor; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }### Answer: @Test public void testGetNaturalKeyDescriptor() throws NoNaturalKeysDefinedException { Entity e = setup(); TenantContext.setTenantId("someTenant"); NaturalKeyDescriptor desc = naturalKeyExtractor.getNaturalKeyDescriptor(e); Map<String, String> naturalKeys = desc.getNaturalKeys(); Assert.assertEquals(COLLECTION_TYPE, desc.getEntityType()); Assert.assertEquals("someTenant", desc.getTenantId()); Assert.assertEquals(1, naturalKeys.size()); Assert.assertEquals("someValue", naturalKeys.get("someField")); Mockito.verify(entitySchemaRegistry, Mockito.times(2)).getSchema(Mockito.anyString()); }
### Question: NaturalKeyExtractor implements INaturalKeyExtractor { public String getCollectionName(Entity entity) { NeutralSchema schema = entitySchemaRegistry.getSchema(entity.getType()); if (schema != null) { AppInfo appInfo = schema.getAppInfo(); if (appInfo != null) { return appInfo.getCollectionType(); } } LOG.error("No collectionType found in schema for entity: " + entity.getType()); return null; } @Override Map<String, String> getNaturalKeys(Entity entity); @Override Map<String, Boolean> getNaturalKeyFields(Entity entity); @Override NaturalKeyDescriptor getNaturalKeyDescriptor(Entity entity); String getCollectionName(Entity entity); }### Answer: @Test public void shouldLookupEntityCollection() { Entity e = setup(); AppInfo mockAppInfo = Mockito.mock(AppInfo.class); mockSchema.addAnnotation(mockAppInfo); String collectionName = naturalKeyExtractor.getCollectionName(e); Assert.assertEquals(COLLECTION_TYPE, collectionName); }
### Question: IntegerSchema extends PrimitiveNumericSchema<Integer> { @Override public Object convert(Object value) { if (value instanceof Integer) { return (Integer) value; } else if (value instanceof String) { try { return Integer.parseInt((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException)new IllegalArgumentException(value + " cannot be parsed to an integer").initCause(nfe); } } throw new IllegalArgumentException(value + " is not an integer"); } IntegerSchema(); @Override Object convert(Object value); }### Answer: @Test public void testConvert() throws Exception { int value = 12345; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Integer); Integer convertedInput = (Integer) convertedValue; assertTrue(convertedInput.intValue() == value); } @Test(expected = IllegalArgumentException.class) public void testBadConvert() { this.schema.convert("INVALID INPUT"); } @Test public void testNonConvert() { Object convertedValue = this.schema.convert(12); assertTrue(convertedValue instanceof Integer); } @Test public void testIntegerConverter() { int data = 123; assertTrue("Failure returning same object", this.schema.convert(data).equals(data)); assertTrue("Failure parsing int data", this.schema.convert("" + data).equals(data)); } @Test(expected = IllegalArgumentException.class) public void testInvalidStringThrowsException() throws IllegalArgumentException { this.schema.convert("INVALID INPUT"); } @Test(expected = IllegalArgumentException.class) public void testUnsupportedObjectTypeThrowsException() throws IllegalArgumentException { this.schema.convert(new Object()); }
### Question: BooleanSchema extends PrimitiveSchema { @Override public Object convert(Object value) { if (value instanceof Boolean) { return (Boolean) value; } else if (value instanceof String) { String stringData = (String) value; stringData = stringData.toLowerCase(); if (stringData.equals("true")) { return Boolean.TRUE; } else if (stringData.equals("false")) { return Boolean.FALSE; } else { throw new IllegalArgumentException(stringData + " cannot be parsed to a boolean"); } } throw new IllegalArgumentException(value + " is not a boolean"); } BooleanSchema(); @Override Object convert(Object value); }### Answer: @Test public void testConvert() throws Exception { boolean value = true; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Boolean); Boolean convertedInput = (Boolean) convertedValue; assertTrue(convertedInput.booleanValue() == value); } @Test(expected = IllegalArgumentException.class) public void testInvalidStringThrowsException() throws IllegalArgumentException { this.schema.convert("INVALID INPUT"); } @Test(expected = IllegalArgumentException.class) public void testUnsupportedObjectTypeThrowsException() throws IllegalArgumentException { this.schema.convert(new Object()); } @Test public void testBooleanConverter() { assertTrue("Failure returning same object", this.schema.convert(true).equals(Boolean.TRUE)); assertTrue("Failure returning same object", this.schema.convert(false).equals(Boolean.FALSE)); assertTrue("Failure parsing true", this.schema.convert("true").equals(Boolean.TRUE)); assertTrue("Failure parsing false", this.schema.convert("false").equals(Boolean.FALSE)); }
### Question: DateSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid; try { javax.xml.bind.DatatypeConverter.parseDate((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339 Date", ErrorType.INVALID_DATE_FORMAT, errors); } DateSchema(); DateSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override Object convert(Object value); }### Answer: @Test public void testDateStringValidation() throws IllegalArgumentException { String dateString = "2012-01-01T12:00:00-05:00"; assertTrue("DateTime entity validation failed", schema.validate(dateString)); } @Test public void testDateValidation() { Calendar calendar = Calendar.getInstance(); String dateString = javax.xml.bind.DatatypeConverter.printDate(calendar); assertTrue("Date entity validation failed", schema.validate(dateString)); } @Test public void testValidationOfStringFailure() { String stringEntity = ""; assertFalse("Expected DateSchema string validation failure did not succeed", schema.validate(stringEntity)); }
### Question: ListSchema extends NeutralSchema { public List<NeutralSchema> getList() { return list; } ListSchema(); ListSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); @Override boolean isPrimitive(); void setList(List<NeutralSchema> list); List<NeutralSchema> getList(); @Override boolean isSimple(); void updateAnnotations(); @Override Object convert(Object value); Map<String, NeutralSchema> getFields(); }### Answer: @Test public void testAnnotations() throws IllegalArgumentException { schema.clearFields(); complexSchema.clearFields(); AppInfo d = new AppInfo(null); d.put(AppInfo.READ_ENFORCEMENT_ELEMENT_NAME, new HashSet<String>(Arrays.asList(Right.READ_RESTRICTED.toString()))); complexSchema.addAnnotation(d); schema.getList().add(complexSchema); assertTrue("The schema should have a read_restricted annotation", schema.getAppInfo().getReadAuthorities() .contains(Right.READ_RESTRICTED)); }
### Question: EdOrgExtractHelper implements InitializingBean { @SuppressWarnings("unchecked") public Set<String> getBulkExtractApps() { TenantContext.setIsSystemCall(true); Iterable<Entity> apps = repository.findAll("application", new NeutralQuery()); TenantContext.setIsSystemCall(false); Set<String> appIds = new HashSet<String>(); for (Entity app : apps) { if (app.getBody().containsKey("isBulkExtract") && (Boolean) app.getBody().get("isBulkExtract")) { if (app.getBody().containsKey("registration") && "APPROVED".equals(((Map<String, Object>) app.getBody().get("registration")).get("status"))) { appIds.add(app.getEntityId()); } } } return appIds; } @Override void afterPropertiesSet(); Set<String> getBulkExtractEdOrgs(); Map<String, Set<String>> getBulkExtractEdOrgsPerApp(); @SuppressWarnings("unchecked") Set<String> getBulkExtractApps(); Set<String> getChildEdOrgs(Collection<String> edOrgs); Iterable<Entity> retrieveSEOAS(String teacherId, String edorgId); void logSecurityEvent(Set<String> leas, String entityName, String className); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); Map<String, List<String>> getEdOrgLineages(); void setEdOrgLineages(Map<String, List<String>> edOrgLineages); }### Answer: @Test public void getBulkExtractAppsTest() { when(repository.findAll("application", new NeutralQuery())).thenReturn( Arrays.asList( buildAppEntity("1", true, true), buildAppEntity("2", false, false), buildAppEntity("3", true, false), buildAppEntity("4", false, true), buildAppEntity("5", true, true) ) ); Set<String> bulkExtractApps = helper.getBulkExtractApps(); bulkExtractApps.removeAll(Arrays.asList("1","5")); assertTrue(bulkExtractApps.isEmpty()); }
### Question: TimeSchema extends NeutralSchema { protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = false; try { javax.xml.bind.DatatypeConverter.parseTime((String) entity); isValid = true; } catch (IllegalArgumentException e2) { isValid = false; } return addError(isValid, fieldName, entity, "RFC 3339", ErrorType.INVALID_DATE_FORMAT, errors); } TimeSchema(); TimeSchema(String xsdType); @Override NeutralSchemaType getSchemaType(); }### Answer: @Test public void testTimeStringValidation() throws IllegalArgumentException { String timeString = "12:00:00-05:00"; assertTrue("Time entity validation failed", schema.validate(timeString)); } @Test public void testTimeValidation() { Calendar calendar = Calendar.getInstance(); String timeString = javax.xml.bind.DatatypeConverter.printTime(calendar); assertTrue("Time entity validation failed", schema.validate(timeString)); } @Test public void testValidationOfStringFailure() { String stringEntity = ""; assertFalse("Expected TimeSchema string validation failure did not succeed", schema.validate(stringEntity)); }
### Question: SelfReferenceValidator { public boolean validate(Entity entity, List<ValidationError> errors) { String selfReferencePath = selfReferenceExtractor.getSelfReferenceFields(entity); if (selfReferencePath != null) { Map<String, Object> body = entity.getBody(); if (body != null) { String property = (String) body.get(selfReferencePath); String uuid = entity.getEntityId(); if (uuid == null) { uuid = getDeterministicId(entity); } if (property != null && property.equals(uuid)) { Map<String, String> naturalKeys = null; try { naturalKeys = naturalKeyExtractor.getNaturalKeys(entity); if (naturalKeys != null && naturalKeys.size() > 0) { property = naturalKeys.toString(); } } catch (NoNaturalKeysDefinedException e) { LOG.error(e.getMessage(), e); } errors.add(new ValidationError(ErrorType.SELF_REFERENCING_DATA, selfReferencePath, property, new String[] { "Reference to a separate entity" })); return false; } return true; } } return true; } boolean validate(Entity entity, List<ValidationError> errors); String getDeterministicId(Entity entity); }### Answer: @Test public void testValidate() { Entity entity = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(REFERENCE_FIELD, UUID); Mockito.when(entity.getBody()).thenReturn(body); Mockito.when(entity.getEntityId()).thenReturn(UUID); List<ValidationError> errors = new ArrayList<ValidationError>(); boolean valid = selfReferenceValidator.validate(entity, errors); Assert.assertFalse(valid); Assert.assertEquals(1, errors.size()); }
### Question: NeutralQuery { @Override public String toString() { return "NeutralQuery [includeFields=" + includeFields + ", excludeFields=" + excludeFields + ", offset=" + offset + ", limit=" + limit + ", sortBy=" + sortBy + ", sortOrder=" + sortOrder + ", queryCriteria=" + queryCriteria + ", orQueries=" + orQueries + "]"; } NeutralQuery(); NeutralQuery(int limit); NeutralQuery(NeutralQuery otherNeutralQuery); NeutralQuery(NeutralCriteria neutralCriteria); List<String> getEmbeddedFields(); void setEmbeddedFields(List<String> embeddedFields); @Override int hashCode(); @Override boolean equals(Object obj); NeutralQuery addOrQuery(NeutralQuery orQuery); List<NeutralQuery> getOrQueries(); final NeutralQuery addCriteria(NeutralCriteria criteria); NeutralQuery prependCriteria(NeutralCriteria criteria); List<NeutralCriteria> getCriteria(); List<String> getIncludeFields(); NeutralQuery setIncludeFields(List<String> includeFields); List<String> getExcludeFields(); NeutralQuery setExcludeFields(List<String> excludeFields); boolean removeCriteria(NeutralCriteria criteria); @Deprecated String getIncludeFieldString(); @Deprecated String getExcludeFieldString(); int getOffset(); int getLimit(); String getSortBy(); SortOrder getSortOrder(); NeutralQuery setLimit(int newLimit); NeutralQuery setOffset(int newOffset); NeutralQuery setIncludeFieldString(String newIncludeFields); NeutralQuery setExcludeFieldString(String newExcludeFields); NeutralQuery setEmbeddedFieldString(String newEmbeddedFields); NeutralQuery setSortBy(String newSortBy); NeutralQuery setSortOrder(SortOrder newSortOrder); NeutralQuery setQueryCriteria(List<NeutralCriteria> newQueryCriteria); void setCountOnly(boolean value); boolean getCountOnly(); boolean isCountOnly(); @Override String toString(); }### Answer: @Test public void testToString() { assertNotNull(new NeutralQuery().toString()); }
### Question: TypeResolver { public Set<String> resolveType(String type) { if (typeMaps.containsKey(type)) { return typeMaps.get(type); } return new HashSet<String>(Arrays.asList(type)); } Set<String> resolveType(String type); }### Answer: @Test public void educationOrganzationCollectionAlsoContainsSchools() { Set<String> types = resolver.resolveType("educationOrganization"); assertTrue(types.size() == 2); assertTrue(types.contains("school")); assertTrue(types.contains("educationOrganization")); types = resolver.resolveType("staff"); assertTrue(types.size() == 2); assertTrue(types.contains("teacher")); assertTrue(types.contains("staff")); types = resolver.resolveType("non-existance"); assertTrue(types.size() == 1); }
### Question: EdOrgContextResolverFactory { public ContextResolver getResolver(String entityType) { return resolverMap.get(entityType); } ContextResolver getResolver(String entityType); }### Answer: @Test public void test() { assertNull(factory.getResolver("doesn't exist")); ContextResolver resolver = factory.getResolver("educationOrganization"); assertTrue(resolver instanceof SimpleEntityTypeContextResolver); } @Test public void testStudentParent() { assertTrue(factory.getResolver("studentParentAssociation") instanceof StudentDirectRelatedContextResolver); }
### Question: StaffTeacherDirectRelatedContextResolver extends RelatedContextResolver { @Override protected String getReferenceProperty(String entityType) { if (EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType) \|\| EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType)) { return ParameterConstants.TEACHER_ID; } if (EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_REFERENCE; } if (EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) \|\| EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType)) { return ParameterConstants.STAFF_ID; } return null; } }### Answer: @Test public void canResolveTeacherAndStaffRelatedEntities() { assertEquals(ParameterConstants.TEACHER_ID, resolver.getReferenceProperty(EntityNames.TEACHER_SCHOOL_ASSOCIATION)); assertEquals(ParameterConstants.TEACHER_ID, resolver.getReferenceProperty(EntityNames.TEACHER_SECTION_ASSOCIATION)); assertEquals(ParameterConstants.STAFF_REFERENCE, resolver.getReferenceProperty(EntityNames.STAFF_ED_ORG_ASSOCIATION)); assertEquals(ParameterConstants.STAFF_ID, resolver.getReferenceProperty(EntityNames.STAFF_COHORT_ASSOCIATION)); assertEquals(ParameterConstants.STAFF_ID, resolver.getReferenceProperty(EntityNames.STAFF_PROGRAM_ASSOCIATION)); assertEquals(null, resolver.getReferenceProperty(EntityNames.STAFF)); assertEquals(null, resolver.getReferenceProperty(EntityNames.TEACHER)); }
### Question: StudentCompetencyContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity == null) { return Collections.emptySet(); } String studentSectionAssociationId = (String) entity.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); Entity studentSectionAssociation = repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, studentSectionAssociationId); if (studentSectionAssociation == null) { return Collections.emptySet(); } String studentId = (String) studentSectionAssociation.getBody().get(ParameterConstants.STUDENT_ID); return studentResolver.findGoverningEdOrgs(studentId, entity); } @Override Set<String> findGoverningEdOrgs(Entity entity); }### Answer: @Test public void noStudentSectionAssociation() { Entity studentCompetency = buildStudentCompetency(); when(repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, "association123")).thenReturn(null); assertEquals(Collections.<String> emptySet(), underTest.findGoverningEdOrgs(studentCompetency)); } @Test public void shouldFollowStudent() { Entity studentCompetency = buildStudentCompetency(); when(repo.findById(EntityNames.STUDENT_SECTION_ASSOCIATION, "association123")).thenReturn(buildStudentSectionAssociation()); Set<String> topLeas = new HashSet<String>(Arrays.asList("lea1", "lea2")); when(studentResolver.findGoverningEdOrgs("student123", studentCompetency)).thenReturn(topLeas); assertEquals(topLeas, underTest.findGoverningEdOrgs(studentCompetency)); }
### Question: ParentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> leas = new HashSet<String>(); Iterator<Entity> kids = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(PATH_TO_PARENT).is(entity.getEntityId()))); while(kids.hasNext()) { Entity student = kids.next(); leas.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return leas; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String PATH_TO_PARENT; }### Answer: @Test public void test() { Entity parent = mock(Entity.class); Entity kid1 = mock(Entity.class); when(kid1.getEntityId()).thenReturn("kid1"); Entity kid2 = mock(Entity.class); when(kid2.getEntityId()).thenReturn("kid2"); when(parent.getEntityId()).thenReturn("parentId"); when(repo.findEach(eq("student"), argThat(new BaseMatcher<Query>() { @Override public boolean matches(Object item) { Query q = (Query) item; return q.getQueryObject().get("studentParentAssociation.body.parentId").equals("parentId"); } @Override public void describeTo(Description description) { } }))).thenReturn(Arrays.asList(kid1, kid2).iterator()); when(studentResolver.findGoverningEdOrgs("kid1", parent)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea2"))); when(studentResolver.findGoverningEdOrgs("kid2", parent)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea3"))); assertEquals(new HashSet<String>(Arrays.asList("lea1", "lea2", "lea3")), underTest.findGoverningEdOrgs(parent)); }
### Question: LongValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new LongWritable(Long.parseLong(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {'%s'} to Long", value)); } return rval; } LongValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }### Answer: @Test public void testGetValue() { BSONObject field = new BasicBSONObject("field", 123L); BSONObject entry = new BasicBSONObject("long", field); BSONWritable entity = new BSONWritable(entry); LongValueMapper mapper = new LongValueMapper("long.field"); Writable value = mapper.getValue(entity); assertFalse(value instanceof NullWritable); assertTrue(value instanceof LongWritable); assertEquals(((LongWritable) value).get(), 123L); } @Test public void testValueNotFound() { BSONObject field = new BasicBSONObject("field", 123L); BSONObject entry = new BasicBSONObject("long", field); BSONWritable entity = new BSONWritable(entry); LongValueMapper mapper = new LongValueMapper("long.missing_field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); } @Test public void testValueNotLong() { BSONObject field = new BasicBSONObject("field", true); BSONObject entry = new BasicBSONObject("long", field); BSONWritable entity = new BSONWritable(entry); LongValueMapper mapper = new LongValueMapper("long.field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); }
### Question: RelatedContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { if (entity.getBody() == null) { return Collections.emptySet(); } String referredId = getReferredId(entity.getType(), entity.getBody()); if (referredId == null) { return Collections.emptySet(); } return getReferredResolver().findGoverningEdOrgs(referredId, entity); } RelatedContextResolver(); @Override Set<String> findGoverningEdOrgs(Entity entity); }### Answer: @Test public void testfindGoverningEdOrgs() { Mockito.when(mockEntity.getType()).thenReturn(EntityNames.TEACHER_SCHOOL_ASSOCIATION); Mockito.when(mockEntity.getBody()).thenReturn(body); Set<String> edOrgs = new HashSet<String>(Arrays.asList("springfieldElementary", "springfieldHigh")); Mockito.when(staffTeacherResolver.findGoverningEdOrgs(Mockito.eq(REFERRED_ID), Mockito.eq(mockEntity))).thenReturn(edOrgs); assertTrue(resolver.findGoverningEdOrgs(mockEntity).equals(edOrgs)); }
### Question: RelatedContextResolver implements ContextResolver { protected String getReferredId(String type, Map<String, Object> body) { String reference = getReferenceProperty(type); if (reference == null) { return null; } String referredId = (String) body.get(reference); return referredId; } RelatedContextResolver(); @Override Set<String> findGoverningEdOrgs(Entity entity); }### Answer: @Test public void testgetReferredId() { assertTrue(resolver.getReferredId(EntityNames.TEACHER_SCHOOL_ASSOCIATION, body).equals(REFERRED_ID)); }
### Question: DisciplineIncidentContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> students = repo.findEach(EntityNames.STUDENT, Query.query(Criteria.where(DISCIPLINE_INCIDENT_ID).is(entity.getEntityId()))); while (students.hasNext()) { Entity student = students.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs(student.getEntityId(), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String DISCIPLINE_INCIDENT_ID; }### Answer: @Test public void testSingleStudent() { setFindEachReturn(Arrays.asList(student1)); Assert.assertEquals(new HashSet<String>(Arrays.asList("school1")), resolver.findGoverningEdOrgs(disciplineIncident)); } @Test public void testMultipleStudents() { setFindEachReturn(Arrays.asList(student1, student2, student3)); Assert.assertEquals(new HashSet<String>(Arrays.asList("school1", "school2", "school3")), resolver.findGoverningEdOrgs(disciplineIncident)); } @Test public void testNoStudentDIAssociation() { setFindEachReturn(Arrays.asList(student4)); Assert.assertTrue(resolver.findGoverningEdOrgs(disciplineIncident).isEmpty()); }
### Question: AllPublicDataExtractor implements PublicDataExtractor { @Override public void extract(ExtractFile file) { extractor.setExtractionQuery(new NeutralQuery()); for (PublicEntityDefinition entity : PublicEntityDefinition.values()) { extractor.extractEntities(file, entity.getEntityName(), new Predicate<Entity>() { @Override public boolean apply(Entity input) { boolean shouldExtract = true; if (!isPublicEntity(input.getType())) { shouldExtract = false; } return shouldExtract; } }); } } AllPublicDataExtractor(EntityExtractor extractor); @Override void extract(ExtractFile file); }### Answer: @Test public void testExtract() { publicDataExtractor.extract(file); for (PublicEntityDefinition definition : PublicEntityDefinition.values()) { Mockito.verify(extractor, Mockito.times(1)).extractEntities(Mockito.eq(file), Mockito.eq(definition.getEntityName()), Mockito.any(Predicate.class)); } }
### Question: PublicDataFactory { public PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor) { return new AllPublicDataExtractor(extractor); } PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor); List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor); }### Answer: @Test public void buildUnfilteredPublicDataExtractor() { Assert.assertTrue(factory.buildAllPublicDataExtractor(null) != null); Assert.assertTrue(factory.buildAllPublicDataExtractor(null).getClass() == AllPublicDataExtractor.class); }
### Question: PublicDataFactory { public List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor) { List<PublicDataExtractor> list = new ArrayList<PublicDataExtractor>(); list.add(buildAllPublicDataExtractor(extractor)); return list; } PublicDataExtractor buildAllPublicDataExtractor(EntityExtractor extractor); List<PublicDataExtractor> buildPublicDataExtracts(EntityExtractor extractor); }### Answer: @Test public void testBuildAllPublicDataExtracts() { Assert.assertTrue(factory.buildPublicDataExtracts(null) != null); List<PublicDataExtractor> extractors = factory.buildPublicDataExtracts(null); Assert.assertEquals(extractors.size(), 1); Assert.assertTrue(extractors.get(0).getClass() == AllPublicDataExtractor.class); }
### Question: EnumValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { value = Enum.valueOf(enumClass, value).toString(); rval = new Text(value); } } catch (IllegalArgumentException e) { log.severe(String.format("Failed to convert value {%s} to Enum", value)); } return rval; } EnumValueMapper(String fieldName, Class<T> v); @Override Writable getValue(BSONWritable entity); }### Answer: @Test public void testGetValue() { BSONObject field = new BasicBSONObject("field", "TEST1"); BSONObject entry = new BasicBSONObject("enum", field); BSONWritable entity = new BSONWritable(entry); EnumValueMapper<Testing> m = new EnumValueMapper<Testing>("enum.field", Testing.class); Writable value = m.getValue(entity); assertFalse(value instanceof NullWritable); assertTrue(value instanceof Text); assertEquals(((Text) value).toString(), Testing.TEST1.toString()); } @Test public void testGetValueNotFound() { BSONObject field = new BasicBSONObject("field", "Unknown"); BSONObject entry = new BasicBSONObject("enum", field); BSONWritable entity = new BSONWritable(entry); EnumValueMapper<Testing> m = new EnumValueMapper<Testing>("enum.field", Testing.class); Writable value = m.getValue(entity); assertTrue(value instanceof NullWritable); }
### Question: DoubleValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = null; try { value = BSONUtilities.getValue(entity, fieldName); if (value != null) { rval = new DoubleWritable(Double.parseDouble(value.toString())); } } catch (NumberFormatException e) { log.severe(String.format("Failed to convert value {%s} to Double", value)); } return rval; } DoubleValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }### Answer: @Test public void testGetValue() { BSONObject field = new BasicBSONObject("field", 1.312D); BSONObject entry = new BasicBSONObject("double", field); BSONWritable entity = new BSONWritable(entry); DoubleValueMapper mapper = new DoubleValueMapper("double.field"); Writable value = mapper.getValue(entity); assertFalse(value instanceof NullWritable); assertTrue(value instanceof DoubleWritable); assertEquals(((DoubleWritable) value).get(), 1.312D, 0.05); } @Test public void testValueNotFound() { BSONObject field = new BasicBSONObject("field", 1.312D); BSONObject entry = new BasicBSONObject("double", field); BSONWritable entity = new BSONWritable(entry); DoubleValueMapper mapper = new DoubleValueMapper("double.missing_field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); } @Test public void testGetValueNotDouble() { BSONObject field = new BasicBSONObject("field", "Bob"); BSONObject entry = new BasicBSONObject("double", field); BSONWritable entity = new BSONWritable(entry); DoubleValueMapper mapper = new DoubleValueMapper("double.field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); }
### Question: LogUtil { public static void audit(SecurityEvent event) { if (entityRepository != null) { Map<String, Object> metadata = new HashMap<String, Object>(); metadata.put("tenantId", event.getTenantId()); entityRepository.create("securityEvent", event.getProperties(), metadata, "securityEvent"); } else { LOG.error("Could not log SecurityEvent to the database."); } switch (event.getLogLevel()) { case TYPE_DEBUG: LOG.debug(event.toString()); break; case TYPE_WARN: LOG.warn(event.toString()); break; case TYPE_INFO: LOG.info(event.toString()); break; case TYPE_ERROR: LOG.error(event.toString()); break; case TYPE_TRACE: LOG.trace(event.toString()); break; default: LOG.info(event.toString()); break; } } @Autowired LogUtil(@Qualifier("secondaryRepo") Repository<Entity> repo); static void audit(SecurityEvent event); static Repository<Entity> getEntityRepository(); static void setEntityRepository(Repository<Entity> entityRepository); }### Answer: @Test public void testAudit() { SecurityEvent securityEvent = new SecurityEvent(); securityEvent.setClassName(this.getClass().getName()); securityEvent.setLogMessage("Test Message"); securityEvent.setLogLevel(LogLevelType.TYPE_TRACE); audit(securityEvent); Mockito.verify(mockedEntityRepository, times(1)).create(any(String.class), any(Map.class), any(Map.class), any(String.class)); }
### Question: ErrorFile { public ErrorFile(File parent) { errorFile = new File(parent, ERROR_FILE_NAME); } ErrorFile(File parent); void logEntityError(Entity entity); File getFile(); static final String ERROR_FILE_NAME; }### Answer: @Test public void testErrorFile() throws IOException { File parentDir = new File("./"); parentDir.deleteOnExit(); ErrorFile error = new ErrorFile(parentDir); for (int i=0; i < 3; i++) { Entity entity = Mockito.mock(Entity.class); Mockito.when(entity.getType()).thenReturn("TYPE" + i); error.logEntityError(entity); } Entity entity = Mockito.mock(Entity.class); Mockito.when(entity.getType()).thenReturn("TYPE0"); error.logEntityError(entity); File result = error.getFile(); assertNotNull(result); String errorString = FileUtils.readFileToString(result); assertTrue(errorString.contains("2 errors occurred for entity type TYPE0\n")); assertTrue(errorString.contains("1 errors occurred for entity type TYPE1\n")); assertTrue(errorString.contains("1 errors occurred for entity type TYPE2\n")); }
### Question: EntityWriter { public Entity write(Entity entity, JsonFileWriter file, ErrorFile errors) { Entity treated = applicator.apply(entity); try { file.write(treated); } catch (JsonProcessingException e) { LOG.error("Error while extracting from " + entity.getType(), e); errors.logEntityError(entity); } catch (IOException e) { LOG.error("Error while extracting from " + entity.getType(), e); errors.logEntityError(entity); } return treated; } EntityWriter(Treatment treatment); Entity write(Entity entity, JsonFileWriter file, ErrorFile errors); }### Answer: @Test public void testWrite() { JsonFileWriter file = Mockito.mock(JsonFileWriter.class); ErrorFile errorFile = Mockito.mock(ErrorFile.class); Entity entity = Mockito.mock(Entity.class); Entity check = writer.write(entity, file, errorFile); Assert.assertEquals(treatedEntity, check); try { Mockito.verify(file, Mockito.times(1)).write(treatedEntity); } catch (IOException e) { Assert.fail(); } } @Test public void testIOException() throws IOException { JsonFileWriter file = Mockito.mock(JsonFileWriter.class); Mockito.doThrow(new IOException("Mock IOException")).when(file).write(Mockito.any(Entity.class)); ErrorFile errorFile = Mockito.mock(ErrorFile.class); Entity entity = Mockito.mock(Entity.class); Mockito.when(entity.getType()).thenReturn("MOCK_ENTITY_TYPE"); writer.write(entity, file, errorFile); Mockito.verify(errorFile).logEntityError(entity); Mockito.doThrow(Mockito.mock(JsonProcessingException.class)).when(file).write(Mockito.any(Entity.class)); writer.write(entity, file, errorFile); Mockito.verify(errorFile, Mockito.times(2)).logEntityError(entity); }
### Question: IdFieldEmittableKey extends EmittableKey { @Override public BSONObject toBSON() { BSONObject rval = new BasicBSONObject(); rval.put(getIdField().toString(), getId().toString()); return rval; } IdFieldEmittableKey(); IdFieldEmittableKey(final String mongoFieldName); Text getIdField(); Text getId(); void setId(final Text value); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testToBSON() { IdFieldEmittableKey key = new IdFieldEmittableKey("test.id.key.field"); key.setId(new Text("1234")); BSONObject bson = key.toBSON(); assertNotNull(bson); assertTrue(bson.containsField("test.id.key.field")); Object obj = bson.get("test.id.key.field"); assertNotNull(obj); assertTrue(obj instanceof String); String val = (String) obj; assertEquals(val, "1234"); }
### Question: IdFieldEmittableKey extends EmittableKey { public Text getIdField() { return super.getFieldName(); } IdFieldEmittableKey(); IdFieldEmittableKey(final String mongoFieldName); Text getIdField(); Text getId(); void setId(final Text value); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testGetIdField() { IdFieldEmittableKey key = new IdFieldEmittableKey("test.id.key.field"); assertEquals(key.getIdField().toString(), "test.id.key.field"); }
### Question: RealmResource { @GET @Path("{realmId}") @RightsAllowed({ Right.ADMIN_ACCESS }) public Response readRealm(@PathParam("realmId") String realmId) { EntityBody result = service.get(realmId); return Response.ok(result).build(); } @PostConstruct void init(); void setService(EntityService service); @PUT @Path("{realmId}") @Consumes("application/json") @RightsAllowed({ Right.CRUD_REALM }) Response updateRealm(@PathParam("realmId") String realmId, EntityBody updatedRealm, @Context final UriInfo uriInfo); @DELETE @Path("{realmId}") @RightsAllowed({ Right.CRUD_REALM }) Response deleteRealm(@PathParam("realmId") String realmId, @Context final UriInfo uriInfo); @POST @RightsAllowed({ Right.CRUD_REALM }) Response createRealm(EntityBody newRealm, @Context final UriInfo uriInfo); @GET @Path("{realmId}") @RightsAllowed({ Right.ADMIN_ACCESS }) Response readRealm(@PathParam("realmId") String realmId); @GET @RightsAllowed({ Right.ADMIN_ACCESS }) Response getRealms(@QueryParam(REALM) @DefaultValue("") String realm, @Context UriInfo info); static final String REALM; static final String ED_ORG; static final String RESPONSE; static final String NAME; static final String UNIQUE_IDENTIFIER; static final String IDP_ID; static final String ARTIFACT_RESOLUTION_ENDPOINT; static final String SOURCE_ID; static final String IDP; }### Answer: @Test public void testGetMappingsFound() throws Exception { Response res = resource.readRealm("1234"); Assert.assertEquals(Response.Status.OK.getStatusCode(), res.getStatus()); Assert.assertNotNull(res.getEntity()); } @Test public void testGetMappingsNotFound() throws Exception { Response res = resource.readRealm("-1"); Assert.assertEquals(Response.Status.OK.getStatusCode(), res.getStatus()); Assert.assertNull(res.getEntity()); }
### Question: SamlFederationResource { @GET @Path("metadata") @Produces({ "text/xml" }) public Response getMetadata() { if (!metadata.isEmpty()) { return Response.ok(metadata).build(); } return Response.status(Response.Status.NOT_FOUND).build(); } @GET @Path("metadata") @Produces({ "text/xml" }) Response getMetadata(); @POST @Path("sso/post") Response processPostBinding(@FormParam("SAMLResponse") String postData, @Context UriInfo uriInfo); @GET @Path("sso/artifact") Response processArtifactBinding(@Context HttpServletRequest request, @Context UriInfo uriInfo); static SimpleDateFormat ft; }### Answer: @SuppressWarnings("unchecked") @Test public void getMetadataTest() { Response response = resource.getMetadata(); Assert.assertNotNull(response); Assert.assertEquals(Status.OK.getStatusCode(), response.getStatus()); Assert.assertNotNull(response.getEntity()); Exception exception = null; try { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); InputSource is = new InputSource(new StringReader((String) response.getEntity())); org.w3c.dom.Document doc = db.parse(is); DOMBuilder builder = new DOMBuilder(); org.jdom.Document jdomDocument = builder.build(doc); Iterator<org.jdom.Element> itr = jdomDocument.getDescendants(new ElementFilter()); while (itr.hasNext()) { org.jdom.Element el = itr.next(); if(el.getName().equals("X509Certificate")) { Assert.assertNotNull(el.getText()); } } } catch (ParserConfigurationException e) { exception = e; } catch (SAXException e) { exception = e; } catch (IOException e) { exception = e; } Assert.assertNull(exception); }
### Question: IdFieldEmittableKey extends EmittableKey { @Override public String toString() { return "IdFieldEmittableKey [" + getIdField() + "=" + getId().toString() + "]"; } IdFieldEmittableKey(); IdFieldEmittableKey(final String mongoFieldName); Text getIdField(); Text getId(); void setId(final Text value); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testToString() { IdFieldEmittableKey key = new IdFieldEmittableKey("test.id.key.field"); key.setId(new Text("1234")); assertEquals(key.toString(), "IdFieldEmittableKey [test.id.key.field=1234]"); }
### Question: TenantAndIdEmittableKey extends EmittableKey { @Override public BSONObject toBSON() { BSONObject bson = new BasicBSONObject(); bson.put(getTenantIdField().toString(), getTenantId().toString()); bson.put(getIdField().toString(), getId().toString()); return bson; } TenantAndIdEmittableKey(); TenantAndIdEmittableKey(final String tenantIdFieldName, final String idFieldName); Text getTenantId(); void setTenantId(final Text id); Text getTenantIdField(); Text getId(); void setId(final Text id); Text getIdField(); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testToBSON() { TenantAndIdEmittableKey key = new TenantAndIdEmittableKey("meta.data.tenantId", "test.id.key.field"); key.setTenantId(new Text("Midgar")); key.setId(new Text("1234")); BSONObject bson = key.toBSON(); assertNotNull(bson); assertTrue(bson.containsField("meta.data.tenantId")); Object obj = bson.get("meta.data.tenantId"); assertNotNull(obj); assertTrue(obj instanceof String); String val = (String) obj; assertEquals(val, "Midgar"); assertTrue(bson.containsField("test.id.key.field")); obj = bson.get("test.id.key.field"); assertNotNull(obj); assertTrue(obj instanceof String); val = (String) obj; assertEquals(val, "1234"); }
### Question: ApprovedApplicationResource { @GET @RightsAllowed(any = true) public Response getApplications(@DefaultValue("") @QueryParam("is_admin") String adminFilter) { List<EntityBody> results = new ArrayList<EntityBody>(); NeutralQuery query = new NeutralQuery(0); for (Entity result : repo.findAll("application", query)) { if (appValidator.isAuthorizedForApp(result, SecurityUtil.getSLIPrincipal())) { EntityBody body = new EntityBody(result.getBody()); if (!shouldFilterApp(result, adminFilter)) { filterAttributes(body); results.add(body); } } } return Response.status(Status.OK).entity(results).build(); } @GET @RightsAllowed(any = true) Response getApplications(@DefaultValue("") @QueryParam("is_admin") String adminFilter); static final String RESOURCE_NAME; }### Answer: @SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testGetApps() { ResponseImpl resp = (ResponseImpl) resource.getApplications(""); List<Map> list = (List<Map>) resp.getEntity(); List<String> names = new ArrayList<String>(); for (Map map : list) { String name = (String) map.get("name"); names.add(name); } Assert.assertTrue(names.contains("MyApp")); }
### Question: TenantAndIdEmittableKey extends EmittableKey { public Text getTenantIdField() { return fieldNames[TENANT_FIELD]; } TenantAndIdEmittableKey(); TenantAndIdEmittableKey(final String tenantIdFieldName, final String idFieldName); Text getTenantId(); void setTenantId(final Text id); Text getTenantIdField(); Text getId(); void setId(final Text id); Text getIdField(); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testGetTenantIdField() { TenantAndIdEmittableKey key = new TenantAndIdEmittableKey("meta.data.tenantId", "test.id.key.field"); assertEquals(key.getTenantIdField().toString(), "meta.data.tenantId"); }
### Question: AdminDelegationResource { @GET @Path("myEdOrg") @RightsAllowed({Right.EDORG_DELEGATE, Right.EDORG_APP_AUTHZ }) public Response getSingleDelegation() { EntityBody entity = getEntity(); if (entity == null) { return Response.status(Status.NOT_FOUND).build(); } return Response.status(Status.OK).entity(entity).build(); } @PostConstruct void init(); @GET @RightsAllowed({Right.EDORG_DELEGATE, Right.EDORG_APP_AUTHZ }) Response getDelegations(); @PUT @Path("myEdOrg") @RightsAllowed({Right.EDORG_APP_AUTHZ }) Response setLocalDelegation(EntityBody body, @Context final UriInfo uriInfo); @POST @RightsAllowed({Right.EDORG_APP_AUTHZ }) Response create(EntityBody body, @Context final UriInfo uriInfo); @GET @Path("myEdOrg") @RightsAllowed({Right.EDORG_DELEGATE, Right.EDORG_APP_AUTHZ }) Response getSingleDelegation(); static final String RESOURCE_NAME; static final String LEA_ID; }### Answer: @Test public void testGetSingleDelegation() throws Exception { securityContextInjector.setLeaAdminContext(); ((SLIPrincipal) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).setEdOrg("1234"); ((SLIPrincipal) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).setEdOrgId("1234"); Assert.assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resource.getSingleDelegation().getStatus()); }
### Question: ArtifactBindingHelper { protected Envelope generateSOAPEnvelope(ArtifactResolve artifactResolutionRequest) { XMLObjectBuilderFactory xmlObjectBuilderFactory = Configuration.getBuilderFactory(); Envelope envelope = (Envelope) xmlObjectBuilderFactory.getBuilder(Envelope.DEFAULT_ELEMENT_NAME).buildObject(Envelope.DEFAULT_ELEMENT_NAME); Body body = (Body) xmlObjectBuilderFactory.getBuilder(Body.DEFAULT_ELEMENT_NAME).buildObject(Body.DEFAULT_ELEMENT_NAME); body.getUnknownXMLObjects().add(artifactResolutionRequest); envelope.setBody(body); return envelope; } }### Answer: @Test public void generateSOAPEnvelopeTest() { ArtifactResolve artifactRequest = Mockito.mock(ArtifactResolve.class); Envelope env = artifactBindingHelper.generateSOAPEnvelope(artifactRequest); Assert.assertEquals(artifactRequest, env.getBody().getUnknownXMLObjects().get(0)); Assert.assertEquals(Envelope.DEFAULT_ELEMENT_NAME, env.getElementQName()); }
### Question: TenantAndIdEmittableKey extends EmittableKey { public Text getIdField() { return fieldNames[ID_FIELD]; } TenantAndIdEmittableKey(); TenantAndIdEmittableKey(final String tenantIdFieldName, final String idFieldName); Text getTenantId(); void setTenantId(final Text id); Text getTenantIdField(); Text getId(); void setId(final Text id); Text getIdField(); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testGetIdField() { TenantAndIdEmittableKey key = new TenantAndIdEmittableKey("meta.data.tenantId", "test.id.key.field"); assertEquals(key.getIdField().toString(), "test.id.key.field"); }
### Question: TenantAndIdEmittableKey extends EmittableKey { @Override public String toString() { return "TenantAndIdEmittableKey [" + getIdField() + "=" + getId().toString() + ", " + getTenantIdField() + "=" + getTenantId().toString() + "]"; } TenantAndIdEmittableKey(); TenantAndIdEmittableKey(final String tenantIdFieldName, final String idFieldName); Text getTenantId(); void setTenantId(final Text id); Text getTenantIdField(); Text getId(); void setId(final Text id); Text getIdField(); @Override void readFields(DataInput data); @Override void write(DataOutput data); @Override String toString(); @Override BSONObject toBSON(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(EmittableKey other); }### Answer: @Test public void testToString() { TenantAndIdEmittableKey key = new TenantAndIdEmittableKey("meta.data.tenantId", "test.id.key.field"); key.setTenantId(new Text("Midgar")); key.setId(new Text("1234")); assertEquals(key.toString(), "TenantAndIdEmittableKey [test.id.key.field=1234, meta.data.tenantId=Midgar]"); }
### Question: StringValueMapper extends ValueMapper { @Override public Writable getValue(BSONWritable entity) { Writable rval = NullWritable.get(); String value = BSONUtilities.getValue(entity, fieldName); if (value != null && value instanceof String) { rval = new Text(value); } return rval; } StringValueMapper(String fieldName); @Override Writable getValue(BSONWritable entity); }### Answer: @Test public void testGetValue() { BSONObject field = new BasicBSONObject("field", "testing123"); BSONObject entry = new BasicBSONObject("string", field); BSONWritable entity = new BSONWritable(entry); StringValueMapper mapper = new StringValueMapper("string.field"); Writable value = mapper.getValue(entity); assertFalse(value instanceof NullWritable); assertTrue(value instanceof Text); assertEquals(value.toString(), "testing123"); } @Test public void testValueNotFound() { BSONObject field = new BasicBSONObject("field", "testing123"); BSONObject entry = new BasicBSONObject("string", field); BSONWritable entity = new BSONWritable(entry); StringValueMapper mapper = new StringValueMapper("string.missing_field"); Writable value = mapper.getValue(entity); assertTrue(value instanceof NullWritable); }
### Question: ObjectXMLWriter implements MessageBodyWriter { @Override public boolean isWriteable(Class type, Type genericType, Annotation[] annotations, MediaType mediaType) { if (type.getName().equals("org.slc.sli.api.representation.Home") \|\| type.getName().equals("org.slc.sli.api.representation.ErrorResponse")) { return true; } return false; } @Override boolean isWriteable(Class type, Type genericType, Annotation[] annotations, MediaType mediaType); @Override long getSize(Object o, Class type, Type genericType, Annotation[] annotations, MediaType mediaType); @Override void writeTo(Object o, Class type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, OutputStream entityStream); }### Answer: @Test public void testIsWritable() { assertTrue(writer.isWriteable(ErrorResponse.class, null, null, null)); assertTrue(writer.isWriteable(Home.class, null, null, null)); assertFalse(writer.isWriteable(EntityResponse.class, null, null, null)); }
### Question: XMLMsgBodyReader implements MessageBodyReader<EntityBody> { @Override public EntityBody readFrom(Class<EntityBody> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { EntityBody body = null; if (entityStream != null) { try { body = reader.deserialize(entityStream); } catch (XMLStreamException e) { throw new WebApplicationException(e, Response.Status.BAD_REQUEST); } } else { body = new EntityBody(); } return body; } @Override boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType); @Override EntityBody readFrom(Class<EntityBody> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream); }### Answer: @Test public void testNullStream() throws IOException { EntityBody body = reader.readFrom(EntityBody.class, null, null, null, null, null); assertNotNull("Should not be null", body); assertTrue("Should be empty", body.isEmpty()); } @Test public void testBadXml() throws Exception { try { InputStream is = new ByteArrayInputStream("{\"test\":\"foo\"}".getBytes()); reader.readFrom(EntityBody.class, null, null, null, null, is); fail("Should throw Exception because of invalid XML format"); } catch(WebApplicationException wae) { assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), wae.getResponse().getStatus()); } }
### Question: ExtractorImpl implements Extractor { @Override public void execute() { Future<String> call; List<Future<String>> futures = new LinkedList<Future<String>>(); for (String tenant : tenants) { try { call = executor.submit(new ExtractWorker(tenant)); futures.add(call); } catch (FileNotFoundException e) { LOG.error("Error while extracting data for tenant " + tenant, e); } } for (Future<String> future : futures) { processFuture(future); } destroy(); } void destroy(); void init(); void createExtractDir(); @Override void execute(); @Override void execute(String tenant); @Override String getHealth(); File extractEntity(String tenant, OutstreamZipFile zipFile, String entityName); void setExtractDir(String extractDir); void setExecutorThreads(int executorThreads); void setRunOnStartup(boolean runOnStartup); void setEntityRepository(Repository<Entity> entityRepository); void setTenants(List<String> tenants); void setEntities(List<String> entities); void setQueriedEntities(Map<String, String> queriedEntities); void setCombinedEntities(Map<String, List<String>> combinedEntities); }### Answer: @Test public void testExtractMultipleTenantsIntoSeparateZipFiles() throws Exception { extractor.execute(); File zipFile1 = new File(extractDir, TENANT1 + ".zip"); Assert.assertTrue(zipFile1.length() > 0); File zipFile2 = new File(extractDir, TENANT2 + ".zip"); Assert.assertTrue(zipFile2.length() > 0); }
### Question: EntityXMLWriter implements MessageBodyWriter<EntityResponse> { @Override public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { if (type.getName().equals("org.slc.sli.api.representation.EntityResponse")) { return true; } return false; } @Override boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType); @Override long getSize(EntityResponse entityResponse, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType); @Override void writeTo(EntityResponse entityResponse, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream); }### Answer: @Test public void testIsWritable() { assertFalse(writer.isWriteable(ErrorResponse.class, null, null, null)); assertFalse(writer.isWriteable(Home.class, null, null, null)); assertTrue(writer.isWriteable(EntityResponse.class, null, null, null)); }
### Question: FourPartResource extends GenericResource { @GET public Response get(@Context final UriInfo uriInfo, @PathParam("id") final String id) { return getAllResponseBuilder.build(uriInfo, ResourceTemplate.FOUR_PART, ResourceMethod.GET, new GetResourceLogic() { @Override public ServiceResponse run(Resource resource) { final Resource base = resourceHelper.getBaseName(uriInfo, ResourceTemplate.FOUR_PART); final Resource association = resourceHelper.getAssociationName(uriInfo, ResourceTemplate.FOUR_PART); return resourceService.getEntities(base, id, association, resource, uriInfo.getRequestUri()); } }); } @GET Response get(@Context final UriInfo uriInfo, @PathParam("id") final String id); }### Answer: @Test public void testGet() throws URISyntaxException { String studentId = resourceService.postEntity(studentResource, createTestEntity()); String sectionId = resourceService.postEntity(sectionResource, createSectionEntity()); String assocId = resourceService.postEntity(ssaResource, createAssociationEntity(studentId, sectionId)); setupMocks(BASE_URI + "/" + studentId + "/studentSectionAssociations/sections"); Response response = fourPartResource.get(uriInfo, studentId); assertEquals("Status code should be OK", Response.Status.OK.getStatusCode(), response.getStatus()); }
### Question: ChangedUriInfo implements UriInfo { @Override public String getPath() { String uriPath = this.uri.getPath(); if (uriPath != null) { String removeString = "/rest/"; if (uriPath.startsWith(removeString)) { return uriPath.substring(removeString.length()); } return uriPath; } return null; } ChangedUriInfo(String uri, UriInfo uriInfo); String getOriginalUri(); @Override String getPath(); @Override String getPath(boolean decode); @Override List<PathSegment> getPathSegments(); @Override List<PathSegment> getPathSegments(boolean decode); @Override URI getRequestUri(); @Override UriBuilder getRequestUriBuilder(); @Override URI getAbsolutePath(); @Override UriBuilder getAbsolutePathBuilder(); @Override URI getBaseUri(); @Override UriBuilder getBaseUriBuilder(); @Override MultivaluedMap<String, String> getPathParameters(); @Override MultivaluedMap<String, String> getPathParameters(boolean decode); @Override MultivaluedMap<String, String> getQueryParameters(); @Override MultivaluedMap<String, String> getQueryParameters(boolean decode); @Override List<String> getMatchedURIs(); @Override List<String> getMatchedURIs(boolean decode); @Override List<Object> getMatchedResources(); static final String ORIGINAL_REQUEST_KEY; }### Answer: @Test public void testGetPath() { assertTrue(new ChangedUriInfo("/rest/foo/bar", null).getPath().equals("foo/bar")); }
### Question: ResourceServiceHelper { protected ApiQuery addTypeCriteria(EntityDefinition entityDefinition, ApiQuery apiQuery) { if (apiQuery != null && entityDefinition != null) { if( !entityDefinition.getType().equals(entityDefinition.getStoredCollectionName())) { apiQuery.addCriteria(new NeutralCriteria("type", NeutralCriteria.CRITERIA_IN, Arrays.asList(entityDefinition.getDbType()), false)); } NeutralCriteria criteria = entityDefinition.getTypeCriteria(); if(criteria != null) { apiQuery.addCriteria(criteria); } } return apiQuery; } ApiQuery getApiQuery(EntityDefinition definition, final URI requestURI); ApiQuery getApiQuery(EntityDefinition definition); }### Answer: @Test public void testAddTypeCriteria() { EntityDefinition def = entityDefs.lookupByResourceName(ResourceNames.TEACHERS); ApiQuery query = new ApiQuery(); query = resourceServiceHelper.addTypeCriteria(def, query); List<NeutralCriteria> criteriaList = query.getCriteria(); assertEquals("Should match", 1, criteriaList.size()); NeutralCriteria criteria = criteriaList.get(0); assertEquals("Should match", "type", criteria.getKey()); assertEquals("Should match", NeutralCriteria.CRITERIA_IN, criteria.getOperator()); assertEquals("Should match", Arrays.asList(def.getType()), criteria.getValue()); } @Test public void testAddTypeCriteriaNoChange() { EntityDefinition def = entityDefs.lookupByResourceName(ResourceNames.STAFF); ApiQuery query = new ApiQuery(); query = resourceServiceHelper.addTypeCriteria(def, query); List<NeutralCriteria> criteriaList = query.getCriteria(); assertEquals("Should match", 0, criteriaList.size()); } @Test public void testAddTypeCriteriaNullValues() { ApiQuery query = null; assertNull("Should be null", resourceServiceHelper.addTypeCriteria(null, null)); query = new ApiQuery(); query = resourceServiceHelper.addTypeCriteria(null, query); List<NeutralCriteria> criteriaList = query.getCriteria(); assertEquals("Should match", 0, criteriaList.size()); }
### Question: WordCountCascading { public void execute(String inputPath, String outputPath) { Scheme sourceScheme = new TextLine( new Fields( "line" ) ); Tap source = new Hfs( sourceScheme, inputPath ); Scheme sinkScheme = new TextLine( new Fields( "word", "count" ) ); Tap sink = new Hfs( sinkScheme, outputPath, SinkMode.REPLACE ); Pipe assembly = new Pipe( "wordcount" ); String regex = "(?<!\\pL)(?=\\pL)[^ ]*(?<=\\pL)(?!\\pL)"; Function function = new RegexGenerator( new Fields( "word" ), regex ); assembly = new Each( assembly, new Fields( "line" ), function ); assembly = new GroupBy( assembly, new Fields( "word" ) ); Aggregator count = new Count( new Fields( "count" ) ); assembly = new Every( assembly, count ); Properties properties = new Properties(); FlowConnector.setApplicationJarClass( properties, WordCountCascading.class ); FlowConnector flowConnector = new FlowConnector( properties ); Flow flow = flowConnector.connect( "word-count", source, sink, assembly ); flow.complete(); } void execute(String inputPath, String outputPath); }### Answer: @Test public void testExecute() { WordCountCascading wc = new WordCountCascading(); wc.execute("src/main/resources/short.txt", "target/cascading-result"); System.out.println("completed Cascading word count"); }
### Question: DefaultResourceService implements ResourceService { @Override @MigratePostedEntity public String postEntity(final Resource resource, EntityBody entity) { EntityDefinition definition = resourceHelper.getEntityDefinition(resource); List<String> entityIds = new ArrayList<String>(); if (SecurityUtil.isStaffUser()) { entityIds = definition.getService().createBasedOnContextualRoles(adapter.migrate(entity, definition.getResourceName(), POST)); } else { entityIds = definition.getService().create(adapter.migrate(entity, definition.getResourceName(), POST)); } return StringUtils.join(entityIds.toArray(), ","); } @PostConstruct void init(); @Override @MigrateResponse ServiceResponse getEntitiesByIds(final Resource resource, final String idList, final URI requestURI); @Override @MigrateResponse ServiceResponse getEntities(final Resource resource, final URI requestURI, final boolean getAllEntities); @Override @MigratePostedEntity String postEntity(final Resource resource, EntityBody entity); @Override @MigratePostedEntity void putEntity(Resource resource, String id, EntityBody entity); @Override @MigratePostedEntity void patchEntity(Resource resource, String id, EntityBody entity); @Override void deleteEntity(Resource resource, String id); @Override String getEntityType(Resource resource); @Override CalculatedData<String> getCalculatedData(Resource resource, String id); @Override CalculatedData<Map<String, Integer>> getAggregateData(Resource resource, String id); @SuppressWarnings({ "unchecked", "rawtypes" }) @Override @MigrateResponse ServiceResponse getEntities(final Resource base, final String id, final Resource resource, final URI requestURI); @Override ServiceResponse getEntities(Resource base, String id, Resource association, Resource resource, URI requestUri); }### Answer: @Test public void testCreate() { String id = resourceService.postEntity(resource, new EntityBody(createTestEntity())); assertNotNull("ID should not be null", id); }
### Question: DefaultResourceService implements ResourceService { @Override public String getEntityType(Resource resource) { return resourceHelper.getEntityDefinition(resource).getType(); } @PostConstruct void init(); @Override @MigrateResponse ServiceResponse getEntitiesByIds(final Resource resource, final String idList, final URI requestURI); @Override @MigrateResponse ServiceResponse getEntities(final Resource resource, final URI requestURI, final boolean getAllEntities); @Override @MigratePostedEntity String postEntity(final Resource resource, EntityBody entity); @Override @MigratePostedEntity void putEntity(Resource resource, String id, EntityBody entity); @Override @MigratePostedEntity void patchEntity(Resource resource, String id, EntityBody entity); @Override void deleteEntity(Resource resource, String id); @Override String getEntityType(Resource resource); @Override CalculatedData<String> getCalculatedData(Resource resource, String id); @Override CalculatedData<Map<String, Integer>> getAggregateData(Resource resource, String id); @SuppressWarnings({ "unchecked", "rawtypes" }) @Override @MigrateResponse ServiceResponse getEntities(final Resource base, final String id, final Resource resource, final URI requestURI); @Override ServiceResponse getEntities(Resource base, String id, Resource association, Resource resource, URI requestUri); }### Answer: @Test public void testGetEntityType() { assertEquals("Should match", "student", resourceService.getEntityType(new Resource("v1", "students"))); assertEquals("Should match", "staff", resourceService.getEntityType(new Resource("v1", "staff"))); assertEquals("Should match", "teacher", resourceService.getEntityType(new Resource("v1", "teachers"))); }
### Question: PublicDefaultResource extends DefaultResource { @Override @GET public Response getAll(@Context final UriInfo uriInfo) { return getAllResponseBuilder.build(uriInfo, ResourceTemplate.ONE_PART, ResourceMethod.GET, new GetResourceLogic() { @Override public ServiceResponse run(Resource resource) { return resourceService.getEntities(resource, uriInfo.getRequestUri(), true); } }); } @Override @GET Response getAll(@Context final UriInfo uriInfo); }### Answer: @Test public void testGetAll() throws URISyntaxException { setupMocks(BASE_URI); Response response = publicDefaultResource.getAll(uriInfo); assertEquals("Status code should be OK", Response.Status.OK.getStatusCode(), response.getStatus()); }
### Question: AssessmentResource extends GenericResource { @GET public Response get(@Context final UriInfo uriInfo, @PathParam("id") final String id) { return getAllResponseBuilder.build(uriInfo, ResourceTemplate.THREE_PART, ResourceMethod.GET, new GetResourceLogic() { @Override public ServiceResponse run(Resource resource) { final Resource base = resourceHelper.getBaseName(uriInfo, ResourceTemplate.THREE_PART); return assessmentResourceService.getLearningStandards(base, id, resource, uriInfo.getRequestUri()); } }); } @GET Response get(@Context final UriInfo uriInfo, @PathParam("id") final String id); }### Answer: @Test public void testGet() throws URISyntaxException { String learningStandardId = resourceService.postEntity(learningStandards, createLearningStandardEntity()); String assessmentId = resourceService.postEntity(assessments, createAssessmentEntity(learningStandardId)); setupMocks(BASE_URI + "/" + assessmentId + "/learningStandards"); Response response = assessmentResource.get(uriInfo, assessmentId); assertEquals("Status code should be OK", Response.Status.OK.getStatusCode(), response.getStatus()); EntityResponse entityResponse = (EntityResponse) response.getEntity(); assertEquals("Should match", 1, ((List<EntityBody>) entityResponse.getEntity()).size()); }
### Question: ResourceEndPoint { protected String getResourceClass(final String resourcePath, ResourceEndPointTemplate template) { if (template.getResourceClass() != null) { return template.getResourceClass(); } String resourceClass = bruteForceMatch(resourcePath); return resourceClass; } @PostConstruct void load(); List<String> getQueryingDisallowedEndPoints(); Set<String> getDateRangeDisallowedEndPoints(); Set<String> getBlockGetRequestEndPoints(); Map<String, String> getResources(); Map<String, SortedSet<String>> getNameSpaceMappings(); void setNameSpaceMappings(Map<String, SortedSet<String>> nameSpaceMappings); }### Answer: @Test public void testGetResourceClass() { ResourceEndPointTemplate template = new ResourceEndPointTemplate(); template.setResourceClass("templateClass"); assertEquals("Should match", "templateClass", resourceEndPoint.getResourceClass("/students", template)); template.setResourceClass(null); assertEquals("Should match", "org.slc.sli.api.resources.generic.FourPartResource", resourceEndPoint.getResourceClass("/students", template)); } @Test(expected = RuntimeException.class) public void testNoClass() { ResourceEndPointTemplate template = new ResourceEndPointTemplate(); template.setResourceClass(null); when(resourceHelper.resolveResourcePath("/students", ResourceTemplate.FOUR_PART)).thenReturn(false); when(resourceHelper.resolveResourcePath("/students", ResourceTemplate.THREE_PART)).thenReturn(false); when(resourceHelper.resolveResourcePath("/students", ResourceTemplate.TWO_PART)).thenReturn(false); when(resourceHelper.resolveResourcePath("/students", ResourceTemplate.ONE_PART)).thenReturn(false); resourceEndPoint.getResourceClass("/students", template); }
### Question: ResourceEndPoint { protected Map<String, String> buildEndPoints(String nameSpace, String resourcePath, ResourceEndPointTemplate template) { Map<String, String> resources = new HashMap<String, String>(); String fullPath = nameSpace + resourcePath + template.getPath(); resources.put(fullPath, getResourceClass("/rest/" + fullPath, template)); List<ResourceEndPointTemplate> subResources = template.getSubResources(); if (subResources != null) { for (ResourceEndPointTemplate subTemplate : subResources) { resources.putAll(buildEndPoints(nameSpace, resourcePath + template.getPath(), subTemplate)); } } return resources; } @PostConstruct void load(); List<String> getQueryingDisallowedEndPoints(); Set<String> getDateRangeDisallowedEndPoints(); Set<String> getBlockGetRequestEndPoints(); Map<String, String> getResources(); Map<String, SortedSet<String>> getNameSpaceMappings(); void setNameSpaceMappings(Map<String, SortedSet<String>> nameSpaceMappings); }### Answer: @Test public void testBuildEndPoints() { when(resourceHelper.resolveResourcePath("/students", ResourceTemplate.THREE_PART)).thenReturn(true); ResourceEndPointTemplate template = new ResourceEndPointTemplate(); template.setPath("/students"); template.setResourceClass("someClass"); ResourceEndPointTemplate subResource = new ResourceEndPointTemplate(); subResource.setPath("/{id}/studentSectionAssociations"); template.setSubResources(Arrays.asList(subResource)); Map<String, String> resources = resourceEndPoint.buildEndPoints("v1", "", template); assertEquals("Should match", 2, resources.keySet().size()); assertEquals("Should match", "someClass", resources.get("v1/students")); assertEquals("Should match", "org.slc.sli.api.resources.generic.ThreePartResource", resources.get("v1/students/{id}/studentSectionAssociations")); }
### Question: WordCountHadoop { public void execute(String inputPath, String outputPath) throws Exception { Configuration conf = new Configuration(); Job job = new Job(conf, "wordcount"); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); job.setMapperClass(Map.class); job.setReducerClass(Reduce.class); job.setInputFormatClass(TextInputFormat.class); job.setOutputFormatClass(TextOutputFormat.class); FileInputFormat.addInputPath(job, new Path(inputPath)); FileOutputFormat.setOutputPath(job, new Path(outputPath)); job.waitForCompletion(true); } void execute(String inputPath, String outputPath); }### Answer: @Test public void testExecute() throws Exception { WordCountHadoop wc = new WordCountHadoop(); wc.execute("src/main/resources/short.txt", "target/hadoop-result"); System.out.println("completed Hadoop word count"); }
### Question: MethodNotAllowedException extends RuntimeException { public Set<String> getAllowedMethods() { return allowedMethods; } MethodNotAllowedException(Set<String> allowedMethods); Set<String> getAllowedMethods(); }### Answer: @Test public void testExceptionMethods() { assertEquals("Should match", 2, exception.getAllowedMethods().size()); assertTrue("Should be true", exception.getAllowedMethods().contains("GET")); assertTrue("Should be true", exception.getAllowedMethods().contains("POST")); }
### Question: ThreePartResource extends GenericResource { @GET public Response get(@Context final UriInfo uriInfo, @PathParam("id") final String id) { return getAllResponseBuilder.build(uriInfo, ResourceTemplate.THREE_PART, ResourceMethod.GET, new GetResourceLogic() { @Override public ServiceResponse run(Resource resource) { final Resource base = resourceHelper.getBaseName(uriInfo, ResourceTemplate.THREE_PART); return resourceService.getEntities(base, id, resource, uriInfo.getRequestUri()); } }); } @GET Response get(@Context final UriInfo uriInfo, @PathParam("id") final String id); }### Answer: @Test public void testGet() throws URISyntaxException { String studentId = resourceService.postEntity(studentResource, createTestEntity()); String sectionId = resourceService.postEntity(sectionResource, createSectionEntity()); String assocId = resourceService.postEntity(ssaResource, createAssociationEntity(studentId, sectionId)); setupMocks(BASE_URI + "/" + studentId + "/studentSectionAssociations"); Response response = threePartResource.get(uriInfo, studentId); assertEquals("Status code should be OK", Response.Status.OK.getStatusCode(), response.getStatus()); }
### Question: ResponseBuilder { protected Resource constructAndCheckResource(final UriInfo uriInfo, final ResourceTemplate template, final ResourceMethod method) { Resource resource = resourceHelper.getResourceName(uriInfo, template); resourceAccessLog.logAccessToRestrictedEntity(uriInfo, resource, GetResponseBuilder.class.toString()); return resource; } }### Answer: @Test public void testConstructAndCheckResource() { Resource resourceContainer = responseBuilder.constructAndCheckResource(uriInfo, ResourceTemplate.ONE_PART, ResourceMethod.GET); assertNotNull("Should not be null", resourceContainer); assertEquals("Should match", "v1", resourceContainer.getNamespace()); assertEquals("Should match", "students", resourceContainer.getResourceType()); }
### Question: DefaultResource extends GenericResource implements CustomEntityReturnable { @GET public Response getAll(@Context final UriInfo uriInfo) { return getAllResponseBuilder.build(uriInfo, onePartTemplate, ResourceMethod.GET, new GetResourceLogic() { @Override public ServiceResponse run(Resource resource) { return resourceService.getEntities(resource, uriInfo.getRequestUri(), false); } }); } DefaultResource(); @GET Response getAll(@Context final UriInfo uriInfo); @POST Response post(final EntityBody entityBody, @Context final UriInfo uriInfo); @GET @Path("{id}") Response getWithId(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PUT @Path("{id}") Response put(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @DELETE @Path("{id}") Response delete(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PATCH @Path("{id}") Response patch(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @Override CustomEntityResource getCustomResource(final String id, final UriInfo uriInfo); }### Answer: @Ignore @Test public void testGetAll() throws URISyntaxException { setupMocks(BASE_URI); Response response = defaultResource.getAll(uriInfo); assertEquals("Status code should be OK", Response.Status.OK.getStatusCode(), response.getStatus()); }
### Question: BigDiffHadoop { public void execute(String inputPath1, String inputPath2, String outputPath) throws Exception { Configuration conf = new Configuration(); Job job = new Job(conf, "bigdiff"); job.setOutputKeyClass(Text.class); job.setOutputValueClass(Text.class); job.setMapperClass(Map.class); job.setReducerClass(Reduce.class); job.setInputFormatClass(TextInputFormat.class); job.setOutputFormatClass(TextOutputFormat.class); FileInputFormat.addInputPath(job, new Path(inputPath1)); FileInputFormat.addInputPath(job, new Path(inputPath2)); FileOutputFormat.setOutputPath(job, new Path(outputPath)); job.waitForCompletion(true); } void execute(String inputPath1, String inputPath2, String outputPath); }### Answer: @Test public void testExecute() throws Exception { BigDiffHadoop bd = new BigDiffHadoop(); bd.execute("src/main/resources/bigdiff/left.txt", "src/main/resources/bigdiff/right-sorted.txt", outputDirectory); System.out.println("completed Hadoop big diff"); }
### Question: DefaultResource extends GenericResource implements CustomEntityReturnable { @POST public Response post(final EntityBody entityBody, @Context final UriInfo uriInfo) { writeValidator.validateWriteRequest(entityBody, uriInfo, SecurityUtil.getSLIPrincipal()); return defaultResponseBuilder.build(uriInfo, onePartTemplate, ResourceMethod.POST, new ResourceLogic() { @Override public Response run(Resource resource) { if (entityBody == null) { return Response.status(Response.Status.BAD_REQUEST).build(); } final String id = resourceService.postEntity(resource, entityBody); final String uri = ResourceUtil.getURI(uriInfo, resourceHelper.extractVersion(uriInfo.getPathSegments()), resource.getResourceType(), id).toString(); return Response.status(Response.Status.CREATED).header("Location", uri).build(); } }); } DefaultResource(); @GET Response getAll(@Context final UriInfo uriInfo); @POST Response post(final EntityBody entityBody, @Context final UriInfo uriInfo); @GET @Path("{id}") Response getWithId(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PUT @Path("{id}") Response put(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @DELETE @Path("{id}") Response delete(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PATCH @Path("{id}") Response patch(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @Override CustomEntityResource getCustomResource(final String id, final UriInfo uriInfo); }### Answer: @Ignore @Test public void testPost() throws URISyntaxException { setupMocks(BASE_URI); Response response = defaultResource.post(createTestEntity(), uriInfo); assertEquals("Status code should be OK", Response.Status.CREATED.getStatusCode(), response.getStatus()); assertNotNull("Should not be null", parseIdFromLocation(response)); }
### Question: DefaultResource extends GenericResource implements CustomEntityReturnable { @DELETE @Path("{id}") public Response delete(@PathParam("id") final String id, @Context final UriInfo uriInfo) { writeValidator.validateWriteRequest(null, uriInfo, SecurityUtil.getSLIPrincipal()); return defaultResponseBuilder.build(uriInfo, twoPartTemplate, ResourceMethod.DELETE, new ResourceLogic() { @Override public Response run(Resource resource) { resourceService.deleteEntity(resource, id); return Response.status(Response.Status.NO_CONTENT).build(); } }); } DefaultResource(); @GET Response getAll(@Context final UriInfo uriInfo); @POST Response post(final EntityBody entityBody, @Context final UriInfo uriInfo); @GET @Path("{id}") Response getWithId(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PUT @Path("{id}") Response put(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @DELETE @Path("{id}") Response delete(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PATCH @Path("{id}") Response patch(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @Override CustomEntityResource getCustomResource(final String id, final UriInfo uriInfo); }### Answer: @Test(expected = EntityNotFoundException.class) public void testDelete() throws URISyntaxException { String id = resourceService.postEntity(resource, createTestEntity()); setupMocks(BASE_URI + "/" + id); Response response = defaultResource.delete(id, uriInfo); assertEquals("Status code should be OK", Response.Status.NO_CONTENT.getStatusCode(), response.getStatus()); defaultResource.getWithId(id, uriInfo); }
### Question: DefaultResource extends GenericResource implements CustomEntityReturnable { @Override public CustomEntityResource getCustomResource(final String id, final UriInfo uriInfo) { final Resource resource = resourceHelper.getResourceName(uriInfo, ResourceTemplate.CUSTOM); return new CustomEntityResource(id, resourceHelper.getEntityDefinition(resource.getResourceType()), resourceHelper); } DefaultResource(); @GET Response getAll(@Context final UriInfo uriInfo); @POST Response post(final EntityBody entityBody, @Context final UriInfo uriInfo); @GET @Path("{id}") Response getWithId(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PUT @Path("{id}") Response put(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @DELETE @Path("{id}") Response delete(@PathParam("id") final String id, @Context final UriInfo uriInfo); @PATCH @Path("{id}") Response patch(@PathParam("id") final String id, final EntityBody entityBody, @Context final UriInfo uriInfo); @Override CustomEntityResource getCustomResource(final String id, final UriInfo uriInfo); }### Answer: @Test public void testGetCustomResource() throws URISyntaxException { String id = resourceService.postEntity(resource, createTestEntity()); setupMocks(BASE_URI + "/" + id); CustomEntityResource resource = defaultResource.getCustomResource(id, uriInfo); assertNotNull("Should not be null", resource); }
### Question: SupportResource { @GET @Path("email") public Object getEmail() { if (!isAuthenticated(SecurityContextHolder.getContext())) { throw new InsufficientAuthenticationException("User must be logged in"); } Map<String, String> emailMap = new HashMap<String, String>(); emailMap.put("email", email); return emailMap; } @GET @Path("email") Object getEmail(); }### Answer: @Test public void testGetEmailFailure() throws Exception { assertNotNull(resource); AnonymousAuthenticationToken anon = new AnonymousAuthenticationToken("anon", "anon", Arrays.<GrantedAuthority>asList(Right.ANONYMOUS_ACCESS)); anon.setAuthenticated(false); SecurityContextHolder.getContext().setAuthentication(anon); try { resource.getEmail(); assertFalse(true); } catch (InsufficientAuthenticationException e) { assertTrue(true); } } @Test public void testGetEmailPass() throws Exception { injector.setEducatorContext(); Map<String, String> returned = (Map<String, String>) resource.getEmail(); assertTrue(returned.get("email").equals(email)); }
### Question: OptionalView implements View { @Override public List<EntityBody> add(List<EntityBody> entities, final String resource, MultivaluedMap<String, String> queryParams) { if (factory == null) { return entities; } List<EntityBody> appendedEntities = entities; List<String> optionalFields = new ArrayList<String>(); if (queryParams.get(ParameterConstants.OPTIONAL_FIELDS) != null) { optionalFields.addAll(queryParams.get(ParameterConstants.OPTIONAL_FIELDS)); } if (queryParams.get(ParameterConstants.VIEWS) != null) { optionalFields.addAll(queryParams.get(ParameterConstants.VIEWS)); } if (!optionalFields.isEmpty()) { for (String type : optionalFields) { for (String appenderType : type.split(",")) { Map<String, String> values = extractOptionalFieldParams(appenderType); OptionalFieldAppender appender = factory.getOptionalFieldAppender(resource + "_" + values.get(OptionalFieldAppenderFactory.APPENDER_PREFIX)); if (appender != null) { appendedEntities = appender.applyOptionalField(entities, values.get(OptionalFieldAppenderFactory.PARAM_PREFIX)); } } } } return appendedEntities; } @Override List<EntityBody> add(List<EntityBody> entities, final String resource, MultivaluedMap<String, String> queryParams); }### Answer: @Test @SuppressWarnings({ "unchecked", "rawtypes" }) public void testAppendOptionalFieldsNoOptionsGiven() { MultivaluedMap map = new MultivaluedMapImpl(); EntityBody body = new EntityBody(); body.put("student", "{\"somekey\":\"somevalue\"}"); List<EntityBody> entities = new ArrayList<EntityBody>(); entities.add(body); entities = optionalView.add(entities, ResourceNames.SECTIONS, map); assertEquals("Should only have one", 1, entities.size()); assertEquals("Should match", body, entities.get(0)); }
### Question: OptionalFieldAppenderFactory { public OptionalFieldAppender getOptionalFieldAppender(String type) { return generators.get(type); } OptionalFieldAppender getOptionalFieldAppender(String type); static final String APPENDER_PREFIX; static final String PARAM_PREFIX; }### Answer: @Test public void testGetViewGenerator() { assertTrue("Should be of type studentassessment", factory.getOptionalFieldAppender(ResourceNames.SECTIONS + "_" + ParameterConstants.OPTIONAL_FIELD_ASSESSMENTS) instanceof StudentAssessmentOptionalFieldAppender); assertTrue("Should be of type studentgradebook", factory.getOptionalFieldAppender(ResourceNames.SECTIONS + "_" + ParameterConstants.OPTIONAL_FIELD_GRADEBOOK) instanceof StudentGradebookOptionalFieldAppender); assertTrue("Should be of type studenttranscript", factory.getOptionalFieldAppender(ResourceNames.SECTIONS + "_" + ParameterConstants.OPTIONAL_FIELD_TRANSCRIPT) instanceof StudentTranscriptOptionalFieldAppender); }
### Question: OptionalFieldAppenderHelper { public EntityBody getEntityFromList(List<EntityBody> list, String field, String value) { if (list == null \|\| field == null \|\| value == null) { return null; } for (EntityBody e : list) { if (value.equals(e.get(field))) { return e; } } return null; } List<EntityBody> queryEntities(String resourceName, String key, List<String> values); List<EntityBody> queryEntities(String resourceName, NeutralQuery query); EntityBody getEntityFromList(List<EntityBody> list, String field, String value); List<EntityBody> getEntitySubList(List<EntityBody> list, String field, String value); List<String> getIdList(List<EntityBody> list, String field); Set<String> getSectionIds(List<EntityBody> entities); }### Answer: @Test public void testGetEntityFromList() { EntityBody body = helper.getEntityFromList(createEntityList(true), "field1", "2"); assertEquals("Should match", "2", body.get("field1")); assertEquals("Should match", "2", body.get("field2")); assertEquals("Should match", "2", body.get("id")); body = helper.getEntityFromList(null, "field1", "2"); assertNull("Should be null", body); body = helper.getEntityFromList(createEntityList(true), null, "2"); assertNull("Should be null", body); body = helper.getEntityFromList(createEntityList(true), "field1", null); assertNull("Should be null", body); body = helper.getEntityFromList(null, null, null); assertNull("Should be null", body); body = helper.getEntityFromList(createEntityList(true), "", ""); assertNull("Should be null", body); }
### Question: OptionalFieldAppenderHelper { public List<EntityBody> getEntitySubList(List<EntityBody> list, String field, String value) { List<EntityBody> results = new ArrayList<EntityBody>(); if (list == null \|\| field == null \|\| value == null) { return results; } for (EntityBody e : list) { if (value.equals(e.get(field))) { results.add(e); } } return results; } List<EntityBody> queryEntities(String resourceName, String key, List<String> values); List<EntityBody> queryEntities(String resourceName, NeutralQuery query); EntityBody getEntityFromList(List<EntityBody> list, String field, String value); List<EntityBody> getEntitySubList(List<EntityBody> list, String field, String value); List<String> getIdList(List<EntityBody> list, String field); Set<String> getSectionIds(List<EntityBody> entities); }### Answer: @Test public void testGetEntitySubList() { List<EntityBody> list = helper.getEntitySubList(createEntityList(true), "field1", "3"); assertEquals("Should match", 2, list.size()); assertEquals("Should match", "3", list.get(0).get("field1")); assertEquals("Should match", "3", list.get(1).get("field1")); list = helper.getEntitySubList(createEntityList(true), "field1", "0"); assertEquals("Should match", 0, list.size()); list = helper.getEntitySubList(null, "field1", "2"); assertEquals("Should match", 0, list.size()); list = helper.getEntitySubList(createEntityList(true), null, "2"); assertEquals("Should match", 0, list.size()); list = helper.getEntitySubList(createEntityList(true), "field1", null); assertEquals("Should match", 0, list.size()); list = helper.getEntitySubList(null, null, null); assertEquals("Should match", 0, list.size()); list = helper.getEntitySubList(createEntityList(true), "", ""); assertEquals("Should match", 0, list.size()); }

Subsets and Splits

No saved queries yet

Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.