Datasets:

Minata
/

1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 269k rows

method2testcases stringlengths 118 6.63k
### Question: LanguageListConverter { public List<String> convert(LanguageList languageList) { if (languageList == null) { return null; } return toSliLanguageList(languageList.getLanguages()); } List<String> convert(LanguageList languageList); }### Answer: @Test public void testNullObject() { List<String> result = converter.convert(null); Assert.assertNull("Address list should be null", result); } @Test public void testEmptyList() { List<String> result = converter.convert(new LanguageList()); Assert.assertEquals(0, result.size()); } @Test public void testEmptyLanguage() { LanguageList list = new LanguageList(); openadk.library.common.Language original = new openadk.library.common.Language(); list.add(original); List<String> result = converter.convert(list); Assert.assertEquals(1, result.size()); String language = result.get(0); Assert.assertEquals("Other", language); } @Test public void testConversion() { map.clear(); map.put(LanguageCode.CHECHEN, "Other languages"); map.put(LanguageCode.CHEROKEE, "Cherokee"); map.put(LanguageCode.CHINESE, "Mandarin (Chinese)"); map.put(LanguageCode.ENGLISH, "English"); map.put(LanguageCode.FRENCH, "French"); map.put(LanguageCode.GERMAN, "German"); map.put(LanguageCode.HAWAIIAN, "Other languages"); map.put(LanguageCode.HEBREW, "Hebrew"); map.put(LanguageCode.ITALIAN, "Italian"); map.put(LanguageCode.JAPANESE, "Japanese"); map.put(LanguageCode.KOREAN, "Korean"); map.put(LanguageCode.MOHAWK, "Other languages"); map.put(LanguageCode.MULTIPLE, "Other languages"); map.put(LanguageCode.SPANISH, "Spanish"); map.put(LanguageCode.wrap("something else"), "Other"); List<LanguageCode> languageCodes = new ArrayList<LanguageCode>(); languageCodes.addAll(map.keySet()); LanguageList originalList = new LanguageList(); for (LanguageCode languageCode : languageCodes) { originalList.add(new Language(languageCode)); } List<String> convertedList = converter.convert(originalList); Assert.assertEquals(originalList.size(), convertedList.size()); int i = 0; for (String converted : convertedList) { LanguageCode original = languageCodes.get(i++); Assert.assertEquals(converted, map.get(original)); } }
### Question: TeacherSchoolAssociationExtractVerifier implements ExtractVerifier { @Override public boolean shouldExtract(Entity entity, DateTime upToDate) { Iterable<Entity> seaos = edOrgExtractHelper.retrieveSEOAS((String) entity.getBody().get(ParameterConstants.TEACHER_ID), (String) entity.getBody().get(ParameterConstants.SCHOOL_ID)); return shouldExtract(seaos, upToDate); } @Override boolean shouldExtract(Entity entity, DateTime upToDate); }### Answer: @Test public void testSholdExtractEntities() { List<Entity> seaos = new ArrayList<Entity>(); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "2001-05-24"); Entity entity1 = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); Map<String, Object> body2 = new HashMap<String, Object>(); body2.put(ParameterConstants.BEGIN_DATE, "2009-01-01"); Entity entity2 = new MongoEntity(EntityNames.STUDENT_PROGRAM_ASSOCIATION, body); seaos.add(entity1); seaos.add(entity2); seaos.add(createSEOA("2002-01-01", "2003-01-01")); seaos.add(createSEOA("2005-01-01", "2008-01-01")); Assert.assertFalse(tsaev.shouldExtract(seaos, DateTime.parse("2001-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(seaos, DateTime.parse("2010-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(seaos, DateTime.parse("2006-05-23", DateHelper.getDateTimeFormat()))); } @Test public void testshouldExtractTeacherSchoolAssociation() { Entity mSeoa = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.BEGIN_DATE, "2009-09-02"); body.put(ParameterConstants.END_DATE, "2010-05-31"); Mockito.when(mSeoa.getBody()).thenReturn(body); Mockito.when(mSeoa.getType()).thenReturn(EntityNames.STAFF_ED_ORG_ASSOCIATION); Mockito.when(edOrgExtractHelper.retrieveSEOAS(Matchers.eq("Staff1"), Matchers.eq("LEA"))).thenReturn(Arrays.asList(mSeoa)); Map<String, Object> tsaBody = new HashMap<String, Object>(); tsaBody.put(ParameterConstants.TEACHER_ID, "Staff1"); tsaBody.put(ParameterConstants.SCHOOL_ID, "LEA"); Entity tsa = Mockito.mock(Entity.class); Mockito.when(tsa.getBody()).thenReturn(tsaBody); Mockito.when(tsa.getType()).thenReturn(EntityNames.TEACHER_SCHOOL_ASSOCIATION); Assert.assertTrue(tsaev.shouldExtract(tsa, DateTime.parse("2011-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(tsa, DateTime.parse("2009-09-02", DateHelper.getDateTimeFormat()))); Assert.assertTrue(tsaev.shouldExtract(tsa, null)); Assert.assertFalse(tsaev.shouldExtract(tsa, DateTime.parse("2009-09-01", DateHelper.getDateTimeFormat()))); Assert.assertFalse(tsaev.shouldExtract(tsa, DateTime.parse("2008-05-24", DateHelper.getDateTimeFormat()))); }
### 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: CustomEventGenerator { public static Event generateEvent(String messageFile, EventAction eventAction) { FileReader in = null; Event event = null; try { SIFParser p = SIFParser.newInstance(); in = new FileReader(messageFile); StringBuffer xml = new StringBuffer(); int bufSize = 4096; char[] buf = new char[bufSize]; while (in.ready()) { bufSize = in.read(buf, 0, buf.length); xml.append(buf, 0, bufSize); } SIFDataObject generic = (SIFDataObject) p.parse(xml.toString(), null, 0, SIFVersion.SIF23); event = new Event(generic, eventAction); } catch (SIFException e) { LOG.error("Caught exception trying to load entity from file", e); } catch (ADKParsingException e) { LOG.error("Caught exception trying to load entity from file", e); } catch (ADKException e) { LOG.error("Caught exception trying to load entity from file", e); } catch (IOException e) { LOG.error("Caught exception trying to load entity from file", e); } finally { if (in != null) { try { in.close(); } catch (IOException e) { LOG.warn("Unable to close file", e); } } } return event; } static Event generateEvent(String messageFile, EventAction eventAction); }### Answer: @Test public void testGenerateStudentPersonalDefaultEvent() throws ADKException { String messageFile = getPathForFile("/element_xml/StudentPersonal.xml"); Event studentPersonalEvent = CustomEventGenerator.generateEvent(messageFile, EventAction.ADD); EventAction eventAction = studentPersonalEvent.getAction(); Assert.assertEquals(EventAction.ADD, eventAction); checkStudentPersonal(studentPersonalEvent); } @Test public void testGenerateLeaInfoDefaultEvent() throws ADKException { String messageFile = getPathForFile("/element_xml/LEAInfo.xml"); Event leaInfoEvent = CustomEventGenerator.generateEvent(messageFile, EventAction.ADD); EventAction eventAction = leaInfoEvent.getAction(); Assert.assertEquals(EventAction.ADD, eventAction); checkLeaInfo(leaInfoEvent); }
### Question: SifEntityGenerator { public static StudentLEARelationship generateTestStudentLeaRelationship() { StudentLEARelationship retVal = new StudentLEARelationship(); retVal.setRefId(TEST_STUDENTLEARELATIONSHIP_REFID); retVal.setStudentPersonalRefId(TEST_STUDENTPERSONAL_REFID); retVal.setLEAInfoRefId(TEST_LEAINFO_REFID); retVal.setSchoolYear(2012); retVal.setMembershipType(MembershipType.HOME); OrganizationRelationshipType ort = new OrganizationRelationshipType(); ResidencyStatus rs = new ResidencyStatus(); rs.setCode(PublicSchoolResidenceStatus.RESIDENT); ort.setResidencyStatus(rs); ort.setProvidingInstruction(true); ort.setProvidingServices(true); ort.setFinanciallyResponsible(true); retVal.setLEARelationshipType(ort); retVal.setEntryDate(new GregorianCalendar(2012, 8, 16)); retVal.setEntryType(EntryTypeCode._0619_1838); retVal.setGradeLevel(GradeLevelCode._10); return retVal; } static SchoolInfo generateTestSchoolInfo(); static LEAInfo generateTestLEAInfo(); static SEAInfo generateTestSEAInfo(); static StudentSchoolEnrollment generateTestStudentSchoolEnrollment(); static StudentLEARelationship generateTestStudentLeaRelationship(); static StudentPersonal generateTestStudentPersonal(); static StaffPersonal generateTestStaffPersonal(); static EmployeePersonal generateTestEmployeePersonal(); static StaffAssignment generateTestStaffAssignment(); static EmploymentRecord generateTestEmploymentRecord(); static EmployeeAssignment generateTestEmployeeAssignment(); static final String TEST_SCHOOLINFO_REFID; static final String TEST_LEAINFO_REFID; static final String TEST_SEAINFO_REFID; static final String TEST_STUDENTPERSONAL_REFID; static final String TEST_STUDENTSCHOOLENROLLMENT_REFID; static final String TEST_STUDENTLEARELATIONSHIP_REFID; static final String TEST_STAFFPERSONAL_REFID; static final String TEST_EMPLOYEEPERSONAL_REFID; static final String TEST_STAFFASSIGNMENT_REFID; static final String TEST_EMPLOYMENTRECORD_REFID; static final String TEST_EMPLOYEEASSIGNMENT_REFID; }### Answer: @Test public void testGenerateTestStudentLeaRelationship() { StudentLEARelationship studentLeaRelationship = SifEntityGenerator.generateTestStudentLeaRelationship(); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTLEARELATIONSHIP_REFID, studentLeaRelationship.getRefId()); Assert.assertEquals(SifEntityGenerator.TEST_LEAINFO_REFID, studentLeaRelationship.getLEAInfoRefId()); Assert.assertEquals(SifEntityGenerator.TEST_STUDENTPERSONAL_REFID, studentLeaRelationship.getStudentPersonalRefId()); Assert.assertEquals(2012, studentLeaRelationship.getSchoolYear().intValue()); Assert.assertEquals(MembershipType.HOME.getValue(), studentLeaRelationship.getMembershipType()); Assert.assertEquals(EntryTypeCode._0619_1838.getValue(), studentLeaRelationship.getEntryType().getCode()); Assert.assertEquals(GradeLevelCode._10.getValue(), studentLeaRelationship.getGradeLevel().getCode()); OrganizationRelationshipType organizationRelationshipType = studentLeaRelationship.getLEARelationshipType(); Assert.assertEquals(PublicSchoolResidenceStatus.RESIDENT.getValue(), organizationRelationshipType.getResidencyStatus().getCode()); Assert.assertTrue(organizationRelationshipType.getProvidingInstruction().booleanValue()); Assert.assertTrue(organizationRelationshipType.getProvidingServices().booleanValue()); Assert.assertTrue(organizationRelationshipType.getFinanciallyResponsible().booleanValue()); Calendar entryDate = studentLeaRelationship.getEntryDate(); Assert.assertEquals(2012, entryDate.get(Calendar.YEAR)); Assert.assertEquals(8, entryDate.get(Calendar.MONTH)); Assert.assertEquals(16, entryDate.get(Calendar.DATE)); }
### Question: PropertyUtils { public static Properties getProperties(String[] args) throws ParseException { Properties props = new Properties(); CommandLineParser parser = new PosixParser(); CommandLine cmd = parser.parse(OPTIONS, args); String zoneUrl = cmd.getOptionValue(FLAG_ZONE_URL, DEFAULT_ZONE_URL); String zoneId = cmd.getOptionValue(FLAG_ZONE_ID, DEFAULT_ZONE_ID); String agentId = cmd.getOptionValue(FLAG_AGENT_ID, DEFAULT_AGENT_ID); String script = cmd.getOptionValue(FLAG_SCRIPT, DEFAULT_SCRIPT); String waitTimeStr = cmd.getOptionValue(FLAG_WAIT_TIME, "DEFAULT_WAIT_TIME"); long waitTime; try { waitTime = Long.parseLong(waitTimeStr); } catch (NumberFormatException e) { waitTime = Long.parseLong(DEFAULT_WAIT_TIME); } props.put(KEY_ZONE_URL, zoneUrl); props.put(KEY_ZONE_ID, zoneId); props.put(KEY_AGENT_ID, agentId); props.put(KEY_SCRIPT, script); props.put(KEY_WAIT_TIME, waitTime); String messageFile = cmd.getOptionValue(FLAG_MESSAGE_FILE, DEFAULT_MESSAGE_FILE); props.put(KEY_MESSAGE_FILE, messageFile); String eventAction = cmd.getOptionValue(FLAG_EVENT_ACTION, DEFAULT_EVENT_ACTION); props.put(KEY_EVENT_ACTION, eventAction); return props; } static Properties getProperties(String[] args); static final String KEY_ZONE_URL; static final String KEY_ZONE_ID; static final String KEY_AGENT_ID; static final String KEY_SCRIPT; static final String KEY_WAIT_TIME; static final String KEY_MESSAGE_FILE; static final String KEY_EVENT_ACTION; static final Options OPTIONS; }### Answer: @Test public void testGetPropertiesDefault() throws ParseException { String[] args = {}; Properties props = PropertyUtils.getProperties(args); Assert.assertEquals("test.publisher.agent", props.getProperty(PropertyUtils.KEY_AGENT_ID)); Assert.assertEquals("http: Assert.assertEquals("TestZone", props.getProperty(PropertyUtils.KEY_ZONE_ID)); Assert.assertEquals("LEAInfoAdd", props.getProperty(PropertyUtils.KEY_SCRIPT)); Assert.assertEquals(5000, ((Long) props.get(PropertyUtils.KEY_WAIT_TIME)).longValue()); Assert.assertEquals("", props.getProperty(PropertyUtils.KEY_MESSAGE_FILE)); Assert.assertEquals("ADD", props.getProperty(PropertyUtils.KEY_EVENT_ACTION)); } @Test public void testGetPropertiesNonDefault() throws ParseException { String agentId = "agentId"; String zoneUrl = "http: String zoneId = "MyZone"; String script = "step1,step2,step3"; long waitTime = 9999; String messageFile = "path/to/file"; String eventAction = "DELETE"; String[] args = {"-a", agentId, "-u", zoneUrl, "-z", zoneId, "-s", script, "-w", String.valueOf(waitTime), "-f", messageFile, "-e", eventAction}; Properties props = PropertyUtils.getProperties(args); Assert.assertEquals(agentId, props.getProperty(PropertyUtils.KEY_AGENT_ID)); Assert.assertEquals(zoneUrl, props.getProperty(PropertyUtils.KEY_ZONE_URL)); Assert.assertEquals(zoneId, props.getProperty(PropertyUtils.KEY_ZONE_ID)); Assert.assertEquals(script, props.getProperty(PropertyUtils.KEY_SCRIPT)); Assert.assertEquals(waitTime, ((Long) props.get(PropertyUtils.KEY_WAIT_TIME)).longValue()); Assert.assertEquals(messageFile, props.getProperty(PropertyUtils.KEY_MESSAGE_FILE)); Assert.assertEquals(eventAction, props.getProperty(PropertyUtils.KEY_EVENT_ACTION)); }
### Question: EventReporterAgent extends Agent { public void startAgent() throws Exception { super.initialize(); setProperties(); Zone[] allZones = getZoneFactory().getAllZones(); zoneConfigurator.configure(allZones); } EventReporterAgent(); EventReporterAgent(String id); EventReporterAgent(String id, ZoneConfigurator zoneConfig, Properties agentProperties, Properties httpProperties, Properties httpsProperties, String zoneId, String zoneUrl, SIFVersion sifVersion); void startAgent(); void setConfigFilePath(String configFilePath); String getConfigFilePath(); void setZoneConfigurator(ZoneConfigurator zoneConfigurator); ZoneConfigurator getZoneConfigurator(); void setAgentProperties(Properties agentProperties); Properties getAgentProperties(); void setHttpProperties(Properties httpProperties); Properties getHttpProperties(); void setHttpsProperties(Properties httpsProperties); Properties getHttpsProperties(); void setSifVersion(SIFVersion sifVersion); SIFVersion getSifVersion(); }### Answer: @Test public void shouldCreateAndConfigureAgent() throws Exception { ZoneConfigurator mockZoneConfigurator = Mockito.mock(ZoneConfigurator.class); EventReporterAgent agent = createEventReporterAgent(mockZoneConfigurator); agent.startAgent(); AgentProperties props = agent.getProperties(); Assert.assertEquals("Push", props.getProperty("adk.messaging.mode")); Assert.assertEquals("http", props.getProperty("adk.messaging.transport")); Assert.assertEquals("30000", props.getProperty("adk.messaging.pullFrequency")); Assert.assertEquals("32000", props.getProperty("adk.messaging.maxBufferSize")); Assert.assertEquals("test.publisher.agent", agent.getId()); TransportManager transportManager = agent.getTransportManager(); Transport transport = transportManager.getTransport("http"); TransportProperties transportProperties = transport.getProperties(); Assert.assertEquals("25101", transportProperties.getProperty("port")); Zone[] allZones = agent.getZoneFactory().getAllZones(); Assert.assertNotNull("Agents zones should not be null", allZones); Assert.assertEquals("Agent should be configured with one zone", 1, allZones.length); Assert.assertNotNull("Agent's zone should not be null", allZones[0]); Assert.assertEquals("Agent's zone Id should be TestZone", "TestZone", allZones[0].getZoneId()); Assert.assertEquals("Agent's zone URL should be http: "http: Mockito.verify(mockZoneConfigurator, Mockito.times(1)).configure(Mockito.any(Zone[].class)); }
### 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: EventReporter implements Publisher { public List<Event> runReportScript(String script, long waitTime) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException { List<Event> eventsSent = new ArrayList<Event>(); LOG.info("Wait time (ms): " + waitTime); String[] eventDescriptors = script.split(","); for (String descriptor : eventDescriptors) { GeneratorScriptMethod scriptMethod = GeneratorScriptMethod.get(descriptor); if (scriptMethod == null) { LOG.error("Error retrieving scriptMethod - " + descriptor); } else { LOG.info("Executing script method - " + scriptMethod.toString()); try { Event eventSent = scriptMethod.execute(this); eventsSent.add(eventSent); Thread.sleep(waitTime); } catch (SecurityException e) { LOG.error("Failed to execute method for descriptor " + descriptor, e); } catch (NoSuchMethodException e) { LOG.error("Failed to execute method for descriptor " + descriptor, e); } catch (InterruptedException e) { LOG.error("Exception while sleeping", e); } } } return eventsSent; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void testRunReportScript() throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, ADKException { Map<Class<? extends SIFDataObject>, List<EventAction>> testMap; testMap = new LinkedHashMap<Class<? extends SIFDataObject>, List<EventAction>>(); List<EventAction> addChangeDeleteEventActionList = new ArrayList<EventAction>(); addChangeDeleteEventActionList.add(EventAction.ADD); addChangeDeleteEventActionList.add(EventAction.CHANGE); addChangeDeleteEventActionList.add(EventAction.DELETE); testMap.put(LEAInfo.class, addChangeDeleteEventActionList); testMap.put(SchoolInfo.class, addChangeDeleteEventActionList); testMap.put(StudentPersonal.class, addChangeDeleteEventActionList); testMap.put(StudentLEARelationship.class, addChangeDeleteEventActionList); testMap.put(StudentSchoolEnrollment.class, addChangeDeleteEventActionList); String[] scriptArray = { "LEAInfoAdd", "LEAInfoChange", "LEAInfoDelete", "SchoolInfoAdd", "SchoolInfoChange", "SchoolInfoDelete", "StudentPersonalAdd", "StudentPersonalChange", "StudentPersonalDelete", "StudentLEARelationshipAdd", "StudentLEARelationshipChange", "StudentLEARelationshipDelete", "StudentSchoolEnrollmentAdd", "StudentSchoolEnrollmentChange", "StudentSchoolEnrollmentDelete", "StaffPersonalAdd", "StaffPersonalChange", "StaffPersonalDelete", "EmployeePersonalAdd", "EmployeePersonalChange", "EmployeePersonalDelete", "StaffAssignmentAdd", "StaffAssignmentChange", "StaffAssignmentDelete", "EmploymentRecordAdd", "EmploymentRecordChange", "EmploymentRecordDelete", "EmployeeAssignmentAdd", "EmployeeAssignmentChange", "EmployeeAssignmentDelete" }; String script = ""; for (String item : scriptArray) { script += item + ","; } long waitTime = 0; List<Event> eventsSent = eventReporter.runReportScript(script, waitTime); Mockito.verify(zone, Mockito.times(scriptArray.length)).reportEvent(Mockito.any(Event.class)); Assert.assertEquals(scriptArray.length, eventsSent.size()); int index = 0; for (Class<? extends SIFDataObject> expectedClass : testMap.keySet()) { for (EventAction expectedAction : testMap.get(expectedClass)) { Event event = eventsSent.get(index++); checkScriptedEvent(event, expectedClass, expectedAction); } } }
### Question: EventReporter implements Publisher { public Event reportLeaInfoEvent(EventAction action) throws ADKException { LOG.info("LeaInfo " + action.toString()); LEAInfo leaInfo = SifEntityGenerator.generateTestLEAInfo(); if (action == EventAction.CHANGE) { leaInfo.setChanged(); leaInfo.setLEAURL("http: } Event event = new Event(leaInfo, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportLeaInfoEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = LEAInfo.class; String expectedId = SifEntityGenerator.TEST_LEAINFO_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportLeaInfoEvent(eventAction); LEAInfo dataObject = (LEAInfo) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals("http: eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportLeaInfoEvent(eventAction); dataObject = (LEAInfo) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals("http: eventAction = EventAction.DELETE; sentEvent = eventReporter.reportLeaInfoEvent(eventAction); dataObject = (LEAInfo) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals("http: }
### Question: EventReporter implements Publisher { public Event reportSchoolInfoEvent(EventAction action) throws ADKException { LOG.info("SchoolInfo " + action.toString()); SchoolInfo schoolInfo = SifEntityGenerator.generateTestSchoolInfo(); if (action == EventAction.CHANGE) { schoolInfo.setChanged(); schoolInfo.setSchoolURL("http: } Event event = new Event(schoolInfo, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportSchoolInfoEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = SchoolInfo.class; String expectedId = SifEntityGenerator.TEST_SCHOOLINFO_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportSchoolInfoEvent(eventAction); SchoolInfo dataObject = (SchoolInfo) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals("http: eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportSchoolInfoEvent(eventAction); dataObject = (SchoolInfo) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals("http: eventAction = EventAction.DELETE; sentEvent = eventReporter.reportSchoolInfoEvent(eventAction); dataObject = (SchoolInfo) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals("http: }
### Question: EventReporter implements Publisher { public Event reportStudentPersonalEvent(EventAction action) throws ADKException { LOG.info("StudentPersonal " + action.toString()); StudentPersonal studentPersonal = SifEntityGenerator.generateTestStudentPersonal(); if (action == EventAction.CHANGE) { studentPersonal.setChanged(); studentPersonal.setMigrant(YesNoUnknown.UNKNOWN); } Event event = new Event(studentPersonal, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportStudentPersonalEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = StudentPersonal.class; String expectedId = SifEntityGenerator.TEST_STUDENTPERSONAL_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportStudentPersonalEvent(eventAction); StudentPersonal dataObject = (StudentPersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(YesNoUnknown.NO.getValue(), dataObject.getMigrant()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportStudentPersonalEvent(eventAction); dataObject = (StudentPersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals(YesNoUnknown.UNKNOWN.getValue(), dataObject.getMigrant()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportStudentPersonalEvent(eventAction); dataObject = (StudentPersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(YesNoUnknown.NO.getValue(), dataObject.getMigrant()); }
### Question: EventReporter implements Publisher { public Event reportStudentLeaRelationshipEvent(EventAction action) throws ADKException { LOG.info("StudentLeaRelationship " + action.toString()); StudentLEARelationship studentLeaRelationship = SifEntityGenerator.generateTestStudentLeaRelationship(); if (action == EventAction.CHANGE) { studentLeaRelationship.setChanged(); studentLeaRelationship.setGradeLevel(GradeLevelCode._09); } Event event = new Event(studentLeaRelationship, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportStudentLeaRelationshipEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = StudentLEARelationship.class; String expectedId = SifEntityGenerator.TEST_STUDENTLEARELATIONSHIP_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportStudentLeaRelationshipEvent(eventAction); StudentLEARelationship dataObject = (StudentLEARelationship) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(GradeLevelCode._10.getValue(), dataObject.getGradeLevel().getCode()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportStudentLeaRelationshipEvent(eventAction); dataObject = (StudentLEARelationship) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals(GradeLevelCode._09.getValue(), dataObject.getGradeLevel().getCode()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportStudentLeaRelationshipEvent(eventAction); dataObject = (StudentLEARelationship) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(GradeLevelCode._10.getValue(), dataObject.getGradeLevel().getCode()); }
### Question: EventReporter implements Publisher { public Event reportStudentSchoolEnrollmentEvent(EventAction action) throws ADKException { LOG.info("StudentSchoolEnrollment " + action.toString()); StudentSchoolEnrollment studentSchoolEnrollment = SifEntityGenerator.generateTestStudentSchoolEnrollment(); if (action == EventAction.CHANGE) { studentSchoolEnrollment.setChanged(); studentSchoolEnrollment.setExitType(ExitTypeCode._1923_DIED_OR_INCAPACITATED); } Event event = new Event(studentSchoolEnrollment, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportStudentSchoolEnrollmentEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = StudentSchoolEnrollment.class; String expectedId = SifEntityGenerator.TEST_STUDENTSCHOOLENROLLMENT_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportStudentSchoolEnrollmentEvent(eventAction); StudentSchoolEnrollment dataObject = (StudentSchoolEnrollment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(ExitTypeCode._3502_NOT_ENROLLED_ELIGIBLE_TO.getValue(), dataObject.getExitType().getCode()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportStudentSchoolEnrollmentEvent(eventAction); dataObject = (StudentSchoolEnrollment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals(ExitTypeCode._1923_DIED_OR_INCAPACITATED.getValue(), dataObject.getExitType().getCode()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportStudentSchoolEnrollmentEvent(eventAction); dataObject = (StudentSchoolEnrollment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(ExitTypeCode._3502_NOT_ENROLLED_ELIGIBLE_TO.getValue(), dataObject.getExitType().getCode()); }
### Question: EventReporter implements Publisher { public Event reportStaffPersonalEvent(EventAction action) throws ADKException { LOG.info("StaffPersonal " + action.toString()); StaffPersonal staffPersonal = SifEntityGenerator.generateTestStaffPersonal(); if (action == EventAction.CHANGE) { staffPersonal.setChanged(); staffPersonal.setEmailList(new EmailList(new Email(EmailType.PRIMARY, "[email protected]"))); } Event event = new Event(staffPersonal, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportStaffPersonalEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = StaffPersonal.class; String expectedId = SifEntityGenerator.TEST_STAFFPERSONAL_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportStaffPersonalEvent(eventAction); StaffPersonal dataObject = (StaffPersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); String emailAddress = dataObject.getEmailList().get(0).getValue(); Assert.assertEquals("[email protected]", emailAddress); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportStaffPersonalEvent(eventAction); dataObject = (StaffPersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); emailAddress = dataObject.getEmailList().get(0).getValue(); Assert.assertEquals("[email protected]", emailAddress); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportStaffPersonalEvent(eventAction); dataObject = (StaffPersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); emailAddress = dataObject.getEmailList().get(0).getValue(); Assert.assertEquals("[email protected]", emailAddress); }
### Question: EventReporter implements Publisher { public Event reportEmployeePersonalEvent(EventAction action) throws ADKException { LOG.info("EmployeePersonal " + action.toString()); EmployeePersonal employeePersonal = SifEntityGenerator.generateTestEmployeePersonal(); if (action == EventAction.CHANGE) { employeePersonal.setChanged(); employeePersonal.setOtherIdList(new HrOtherIdList(new OtherId(OtherIdType.CERTIFICATE, "certificate"))); } Event event = new Event(employeePersonal, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportEmployeePersonalEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = EmployeePersonal.class; String expectedId = SifEntityGenerator.TEST_EMPLOYEEPERSONAL_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportEmployeePersonalEvent(eventAction); EmployeePersonal dataObject = (EmployeePersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); OtherId otherId = dataObject.getOtherIdList().get(0); Assert.assertEquals(OtherIdType.SOCIALSECURITY.getValue(), otherId.getType()); Assert.assertEquals("333333333", otherId.getValue()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportEmployeePersonalEvent(eventAction); dataObject = (EmployeePersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); otherId = dataObject.getOtherIdList().get(0); Assert.assertEquals(OtherIdType.CERTIFICATE.getValue(), otherId.getType()); Assert.assertEquals("certificate", otherId.getValue()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportEmployeePersonalEvent(eventAction); dataObject = (EmployeePersonal) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); otherId = dataObject.getOtherIdList().get(0); Assert.assertEquals(OtherIdType.SOCIALSECURITY.getValue(), otherId.getType()); Assert.assertEquals("333333333", otherId.getValue()); }
### Question: EventReporter implements Publisher { public Event reportStaffAssignmentEvent(EventAction action) throws ADKException { LOG.info("StaffAssignment " + action.toString()); StaffAssignment staffAssignment = SifEntityGenerator.generateTestStaffAssignment(); if (action == EventAction.CHANGE) { staffAssignment.setChanged(); staffAssignment.setPrimaryAssignment(YesNo.NO); } Event event = new Event(staffAssignment, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportStaffAssignmentEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = StaffAssignment.class; String expectedId = SifEntityGenerator.TEST_STAFFASSIGNMENT_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportStaffAssignmentEvent(eventAction); StaffAssignment dataObject = (StaffAssignment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(YesNo.YES.getValue(), dataObject.getPrimaryAssignment()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportStaffAssignmentEvent(eventAction); dataObject = (StaffAssignment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals(YesNo.NO.getValue(), dataObject.getPrimaryAssignment()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportStaffAssignmentEvent(eventAction); dataObject = (StaffAssignment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(YesNo.YES.getValue(), dataObject.getPrimaryAssignment()); }
### Question: EventReporter implements Publisher { public Event reportEmploymentRecordEvent(EventAction action) throws ADKException { LOG.info("EmploymentRecord " + action.toString()); EmploymentRecord employmentRecord = SifEntityGenerator.generateTestEmploymentRecord(); if (action == EventAction.CHANGE) { employmentRecord.setChanged(); employmentRecord.setPositionNumber("15"); } Event event = new Event(employmentRecord, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportEmploymentRecordEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = EmploymentRecord.class; String expectedId = SifEntityGenerator.TEST_EMPLOYMENTRECORD_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportEmploymentRecordEvent(eventAction); EmploymentRecord dataObject = (EmploymentRecord) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals("10", dataObject.getPositionNumber()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportEmploymentRecordEvent(eventAction); dataObject = (EmploymentRecord) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals("15", dataObject.getPositionNumber()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportEmploymentRecordEvent(eventAction); dataObject = (EmploymentRecord) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals("10", dataObject.getPositionNumber()); }
### Question: AttendanceExtractVerifier implements ExtractVerifier { @Override public boolean shouldExtract(Entity entity, DateTime upToDate) { String schoolYear = null; if (entity.getBody().containsKey("schoolYearAttendance")) { schoolYear = (String) ((List<Map<String, Object>>) entity.getBody().get("schoolYearAttendance")).get(0).get("schoolYear"); } else { schoolYear = EntityDateHelper.retrieveDate(entity); } return EntityDateHelper.isPastOrCurrentDate(schoolYear, upToDate, entity.getType()); } @Override boolean shouldExtract(Entity entity, DateTime upToDate); }### Answer: @Test public void testshouldExtractEntityBeforeAndAfterTreatment() { Map<String, Object> entityBody = new HashMap<String, Object>(); entityBody.put(ParameterConstants.SCHOOL_YEAR, "2009-2010"); Entity attendance = Mockito.mock(Entity.class); Mockito.when(attendance.getType()).thenReturn(EntityNames.ATTENDANCE); Mockito.when(attendance.getBody()).thenReturn(entityBody); Assert.assertTrue(attendanceExtractVerifier.shouldExtract(attendance, DateTime.parse("2011-05-23", DateHelper.getDateTimeFormat()))); entityBody.clear(); List<Map<String, Object>> schoolYearAttendances = new ArrayList<Map<String, Object>>(); Map<String, Object> schoolYearAttendance = new HashMap<String, Object>(); schoolYearAttendance.put(ParameterConstants.SCHOOL_YEAR, "2009-2010"); schoolYearAttendances.add(schoolYearAttendance); entityBody.put("schoolYearAttendance", schoolYearAttendances); Assert.assertTrue(attendanceExtractVerifier.shouldExtract(attendance, DateTime.parse("2011-05-23", DateHelper.getDateTimeFormat()))); Assert.assertTrue(attendanceExtractVerifier.shouldExtract(attendance, DateTime.parse("2010-05-23", DateHelper.getDateTimeFormat()))); Assert.assertFalse(attendanceExtractVerifier.shouldExtract(attendance, DateTime.parse("2009-05-24", DateHelper.getDateTimeFormat()))); Assert.assertFalse(attendanceExtractVerifier.shouldExtract(attendance, DateTime.parse("2008-05-24", DateHelper.getDateTimeFormat()))); }
### Question: EventReporter implements Publisher { public Event reportEmployeeAssignmentEvent(EventAction action) throws ADKException { LOG.info("EmployeeAssignment " + action.toString()); EmployeeAssignment employeeAssignment = SifEntityGenerator.generateTestEmployeeAssignment(); if (action == EventAction.CHANGE) { employeeAssignment.setChanged(); employeeAssignment.setPrimaryAssignment(YesNo.NO); } Event event = new Event(employeeAssignment, action); zone.reportEvent(event); return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void runReportEmployeeAssignmentEventTests() throws ADKException { Class<? extends SIFDataObject> expectedClass = EmployeeAssignment.class; String expectedId = SifEntityGenerator.TEST_EMPLOYEEASSIGNMENT_REFID; EventAction eventAction = EventAction.ADD; Event sentEvent = eventReporter.reportEmployeeAssignmentEvent(eventAction); EmployeeAssignment dataObject = (EmployeeAssignment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(YesNo.YES.getValue(), dataObject.getPrimaryAssignment()); eventAction = EventAction.CHANGE; sentEvent = eventReporter.reportEmployeeAssignmentEvent(eventAction); dataObject = (EmployeeAssignment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, true); Assert.assertEquals(YesNo.NO.getValue(), dataObject.getPrimaryAssignment()); eventAction = EventAction.DELETE; sentEvent = eventReporter.reportEmployeeAssignmentEvent(eventAction); dataObject = (EmployeeAssignment) runDataObjectEventTest(sentEvent, eventAction, expectedClass, expectedId, false); Assert.assertEquals(YesNo.YES.getValue(), dataObject.getPrimaryAssignment()); }
### Question: EventReporter implements Publisher { public Event reportEvent(String messageFile, String eventAction) throws ADKException { Event event = CustomEventGenerator.generateEvent(messageFile, EventAction.valueOf(eventAction)); if (event == null) { LOG.error("Null event can not be reported"); return null; } if (zone.isConnected()) { zone.reportEvent(event); } else { LOG.error("Zone is not connected"); return null; } return event; } EventReporter(Zone zone); static void main(String[] args); List<Event> runReportScript(String script, long waitTime); Event reportLeaInfoEvent(EventAction action); Event reportSchoolInfoEvent(EventAction action); Event reportStudentPersonalEvent(EventAction action); Event reportStudentLeaRelationshipEvent(EventAction action); Event reportStudentSchoolEnrollmentEvent(EventAction action); Event reportStaffPersonalEvent(EventAction action); Event reportEmployeePersonalEvent(EventAction action); Event reportStaffAssignmentEvent(EventAction action); Event reportEmploymentRecordEvent(EventAction action); Event reportEmployeeAssignmentEvent(EventAction action); Event reportEvent(String messageFile, String eventAction); @Override void onRequest(DataObjectOutputStream out, Query query, Zone zone, MessageInfo info); static final Logger LOG; }### Answer: @Test public void testReportEventValidFile() throws ADKException { URL url = getClass().getResource("/element_xml/StudentPersonal.xml"); String validFilename = url.getPath(); String eventActionStr = EventAction.ADD.toString(); Event event = eventReporter.reportEvent(validFilename, eventActionStr); Assert.assertNotNull(event); EventAction eventAction = event.getAction(); Assert.assertEquals(eventActionStr, eventAction.toString()); Mockito.verify(zone, Mockito.times(1)).reportEvent(Mockito.eq(event)); eventActionStr = EventAction.CHANGE.toString(); event = eventReporter.reportEvent(validFilename, eventActionStr); Assert.assertNotNull(event); eventAction = event.getAction(); Assert.assertEquals(eventActionStr, eventAction.toString()); Mockito.verify(zone, Mockito.times(1)).reportEvent(Mockito.eq(event)); eventActionStr = EventAction.DELETE.toString(); event = eventReporter.reportEvent(validFilename, eventActionStr); Assert.assertNotNull(event); eventAction = event.getAction(); Assert.assertEquals(eventActionStr, eventAction.toString()); Mockito.verify(zone, Mockito.times(1)).reportEvent(Mockito.eq(event)); Mockito.when(zone.isConnected()).thenReturn(false); event = eventReporter.reportEvent(validFilename, EventAction.ADD.toString()); Assert.assertNull(event); Mockito.verify(zone, Mockito.times(0)).reportEvent(Mockito.eq(event)); } @Test public void testReportEventInvalidFile() throws ADKException { String invalidFilename = "doesntexist.xml"; Event event = eventReporter.reportEvent(invalidFilename, EventAction.ADD.toString()); Assert.assertNull(event); Mockito.verify(zone, Mockito.times(0)).reportEvent(Mockito.eq(event)); }
### 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: IDMapper extends Mapper<T, BSONWritable, T, BSONWritable> { @Override public void map(T id, BSONWritable entity, Context context) throws IOException, InterruptedException { for (String field : idFields.values()) { BSONUtilities.removeField(entity, field); } context.write(id, entity); } @Override void map(T id, BSONWritable entity, Context context); }### Answer: @SuppressWarnings("unchecked") @Test public void testMapIdFieldKey() throws Exception { String[] fields = { "data.element.id" }; BSONObject elem = new BasicBSONObject("value", 7631); BSONObject data = new BasicBSONObject("element", elem); BSONObject entry = new BasicBSONObject("data", data); final BSONWritable entity = new BSONWritable(entry); IDMapper<IdFieldEmittableKey> mapper = new IDMapper<IdFieldEmittableKey>(); IDMapper<IdFieldEmittableKey>.Context context = Mockito.mock(IDMapper.Context.class); PowerMockito.when(context, "write", Matchers.any(EmittableKey.class), Matchers.any(BSONObject.class)).thenAnswer(new Answer<BSONObject>() { @Override public BSONObject answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); assertNotNull(args); assertEquals(args.length, 2); assertTrue(args[0] instanceof IdFieldEmittableKey); assertTrue(args[1] instanceof BSONWritable); IdFieldEmittableKey id = (IdFieldEmittableKey) args[0]; assertEquals(id.getIdField().toString(), "data.element.id"); Text idValue = id.getId(); assertEquals(Long.parseLong(idValue.toString()), 3697); BSONWritable e = (BSONWritable) args[1]; assertEquals(e, entity); return null; } }); IdFieldEmittableKey id = new IdFieldEmittableKey(); id.setFieldNames(fields); id.setId(new Text("3697")); mapper.map(id, entity, context); } @SuppressWarnings("unchecked") @Test public void testMapTenantAndIdKey() throws Exception { String[] fields = { "metaData.tenantId", "data.element.id" }; BSONObject elem = new BasicBSONObject("value", 7632); BSONObject data = new BasicBSONObject("element", elem); BSONObject entry = new BasicBSONObject("data", data); final BSONWritable entity = new BSONWritable(entry); BSONObject tenantId = new BasicBSONObject("EdOrgs", "Midtown"); entity.put("metaData", tenantId); IDMapper<TenantAndIdEmittableKey> mapper = new IDMapper<TenantAndIdEmittableKey>(); IDMapper<TenantAndIdEmittableKey>.Context context = Mockito.mock(IDMapper.Context.class); PowerMockito.when(context, "write", Matchers.any(EmittableKey.class), Matchers.any(BSONObject.class)).thenAnswer(new Answer<BSONObject>() { @Override public BSONObject answer(InvocationOnMock invocation) throws Throwable { Object[] args = invocation.getArguments(); assertNotNull(args); assertEquals(args.length, 2); assertTrue(args[0] instanceof TenantAndIdEmittableKey); assertTrue(args[1] instanceof BSONObject); TenantAndIdEmittableKey id = (TenantAndIdEmittableKey) args[0]; assertEquals(id.getIdField().toString(), "data.element.id"); Text idValue = id.getId(); assertEquals(Long.parseLong(idValue.toString()), 90210); assertEquals(id.getTenantIdField().toString(), "metaData.tenantId"); idValue = id.getTenantId(); assertEquals(idValue.toString(), "Midgar"); BSONObject e = (BSONObject) args[1]; assertEquals(e, entity); return null; } }); TenantAndIdEmittableKey id = new TenantAndIdEmittableKey(); id.setFieldNames(fields); id.setTenantId(new Text("Midgar")); id.setId(new Text("90210")); mapper.map(id, entity, context); }
### Question: ReferenceSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValidReference = isValidReference(entity); if (!addError(isValidReference, fieldName, entity, "String", ErrorType.INVALID_DATATYPE, errors)) { return false; } boolean found = false; String collectionType = getEntityType(); try { found = repo.exists(collectionType, (String) entity); } catch (Exception e) { LOG.error("Exception when looking up reference in repository. ", e); } if (!found) { LOG.debug("Broken reference in {}, {}, {}", new Object[] { entity, fieldName, errors }); addError(false, fieldName, entity, "Valid reference", ErrorType.REFERENTIAL_INFO_MISSING, errors); return false; } return true; } ReferenceSchema(String xsdType, SchemaRepository schemaRepository); @Override NeutralSchemaType getSchemaType(); String getEntityType(); @Override Object convert(Object value); }### Answer: @Test public void testReferenceValidation() throws IllegalArgumentException { List<ValidationError> errors = new ArrayList<ValidationError>(); assertTrue("Reference entity validation failed", spySchema.validate(REFERENCE_FIELDNAME, UUID, errors, repo)); } @Test public void testInvalidReferenceValidation() throws IllegalArgumentException { List<ValidationError> errors = new ArrayList<ValidationError>(); assertFalse("Invalid Reference entity validation failed", spySchema.validate(REFERENCE_FIELDNAME, "45679", errors, repo)); } @Test public void testNullReferenceValidation() throws IllegalArgumentException { List<ValidationError> errors = new ArrayList<ValidationError>(); assertFalse("Null reference should not be valid", spySchema.validate(REFERENCE_FIELDNAME, null, errors, repo)); } @Test public void testNonStringReferenceValidation() throws IllegalArgumentException { List<ValidationError> errors = new ArrayList<ValidationError>(); assertFalse("Non-string reference should not be valid", spySchema.validate(REFERENCE_FIELDNAME, new Integer(0), errors, repo)); } @Test public void testEmptyStringReferenceValidation() throws IllegalArgumentException { List<ValidationError> errors = new ArrayList<ValidationError>(); assertFalse("Non-string reference should not be valid", spySchema.validate(REFERENCE_FIELDNAME, "", errors, repo)); }
### 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: EntityDateHelper { protected static boolean isBeforeOrEqualYear(String yearSpan, int upToYear) { int fromYear = Integer.parseInt(yearSpan.split("-")[0]); int toYear = Integer.parseInt(yearSpan.split("-")[1]); return ((upToYear >= toYear) && (upToYear > fromYear)); } 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 testIsBeforeOrEqualYear() { Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2008-2009", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2008-2008", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2009-2008", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2009-2010", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2009-2009", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2010-2009", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2010-2011", 2011)); Assert.assertTrue(EntityDateHelper.isBeforeOrEqualYear("2010-2010", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2011-2010", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2011-2012", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2012-2011", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2012-2013", 2011)); Assert.assertFalse(EntityDateHelper.isBeforeOrEqualYear("2013-2012", 2011)); }
### 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: SecurityEventUtil implements MessageSourceAware { public SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args) { SecurityEvent event = new SecurityEvent(); String seAppId = (appId == null) ? "BulkExtract" : "BulkExtract#" + appId; event.setTenantId(TenantContext.getTenantId()); event.setAppId(seAppId); event.setActionUri(actionDesc); event.setTimeStamp(new Date()); event.setProcessNameOrId(ManagementFactory.getRuntimeMXBean().getName()); try { event.setExecutedOn(InetAddress.getLocalHost().getHostName()); } catch (UnknownHostException e) { LOG.info("Could not find hostname/process for SecurityEventLogging!"); event.setExecutedOn("localhost"); } event.setClassName(loggingClass); event.setLogLevel(logLevel); event.setLogMessage(messageSource.getMessage(code.getCode(), args, "#?" + code.getCode() + "?#", null)); LOG.debug(event.toString()); return event; } SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, String appId, BEMessageCode code, Object... args); SecurityEvent createSecurityEvent(String loggingClass, String actionDesc, LogLevelType logLevel, BEMessageCode code, Object... args); @Override void setMessageSource(MessageSource messageSource); }### Answer: @Test public void testSEValues() { SecurityEventUtil spyObject = Mockito.spy(securityEventUtil); SecurityEvent event = spyObject.createSecurityEvent("class", "Action Description", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001); String appId = null; Mockito.verify(spyObject, Mockito.atMost(1)).createSecurityEvent(Mockito.anyString(), Mockito.anyString(), Mockito.eq(LogLevelType.TYPE_INFO), Mockito.eq(appId), Mockito.eq(BEMessageCode.BE_SE_CODE_0001)); assertEquals("BulkExtract", event.getAppId()); String processName = ManagementFactory.getRuntimeMXBean().getName(); assertEquals(processName, event.getProcessNameOrId()); assertEquals(null, event.getTargetEdOrgList()); }
### 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: ListSchema extends NeutralSchema { @Override protected boolean validate(String fieldName, Object entity, List<ValidationError> errors, Repository<Entity> repo) { boolean isValid = true; Object convertedEntity = convert(entity); if (convertedEntity instanceof Set) { convertedEntity = new ArrayList<Object>((Set) convertedEntity); } if (convertedEntity instanceof List) { List<?> entityList = (List<?>) convertedEntity; for (Object fieldEntity : entityList) { boolean isFieldValid = false; for (NeutralSchema itemSchema : getList()) { if (itemSchema.validate(fieldName, fieldEntity, errors, repo)) { isFieldValid = true; break; } } if (!isFieldValid) { isValid = false; if (errors == null) { return false; } } } if (getProperties() != null) { for (Entry<String, Object> entry : getProperties().entrySet()) { if (Restriction.isRestriction(entry.getKey())) { long restrictionValue = Long.parseLong(entry.getValue().toString()); switch (Restriction.fromValue(entry.getKey())) { case LENGTH: if (!addError(entityList.size() == restrictionValue, fieldName, convertedEntity, "length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MIN_LENGTH: if (!addError(entityList.size() >= restrictionValue, fieldName, convertedEntity, "min-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; case MAX_LENGTH: if (!addError(entityList.size() <= restrictionValue, fieldName, convertedEntity, "max-length=" + restrictionValue, ErrorType.INVALID_VALUE, errors)) { return false; } break; } } } } } else { return addError(false, fieldName, convertedEntity, "List", ErrorType.INVALID_DATATYPE, errors); } return isValid; } 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 testValidationOfBooleanFailure() { Boolean booleanEntity = true; assertFalse("Expected ListSchema boolean validation failure did not succeed", schema.validate(booleanEntity)); } @Test public void testValidationOfIntegerFailure() { Integer integerEntity = 0; assertFalse("Expected ListSchema integer validation failure did not succeed", schema.validate(integerEntity)); } @Test public void testValidationOfFloatFailure() { Float floatEntity = new Float(0); assertFalse("Expected ListSchema float validation failure did not succeed", schema.validate(floatEntity)); }
### 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: ApiNeutralSchemaValidator extends NeutralSchemaValidator { protected Object getValue(String path, Map<String, Object> data) { Object retValue = null; Map<?, ?> values = new HashMap<String, Object>(data); String[] keys = path.split("\\."); for (String key : keys) { Object value = values.get(key); if (Map.class.isInstance(value)) { values = (Map<?, ?>) value; retValue = value; } else { retValue = value; break; } } return retValue; } @Override boolean validateNaturalKeys(final Entity entity, boolean overWrite); }### Answer: @Test public void testGetValueOneLevel() { Map<String, Object> data = new HashMap<String, Object>(); data.put("key1", "value1"); data.put("key2", "value2"); data.put("key3", "value3"); assertEquals("Should match", "value1", apiNeutralSchemaValidator.getValue("key1", data)); assertEquals("Should match", "value2", apiNeutralSchemaValidator.getValue("key2", data)); assertEquals("Should match", "value3", apiNeutralSchemaValidator.getValue("key3", data)); assertEquals("Should match", null, apiNeutralSchemaValidator.getValue("key4", data)); } @Test public void testGetValueMultiLevel() { Map<String, Object> inner2 = new HashMap<String, Object>(); inner2.put("key7", "value7"); inner2.put("key8", "value8"); Map<String, Object> inner1 = new HashMap<String, Object>(); inner1.put("key4", "value4"); inner1.put("key5", "value5"); inner1.put("key6", inner2); Map<String, Object> data = new HashMap<String, Object>(); data.put("key1", "value1"); data.put("key2", "value2"); data.put("key3", inner1); assertEquals("Should match", "value1", apiNeutralSchemaValidator.getValue("key1", data)); assertEquals("Should match", "value2", apiNeutralSchemaValidator.getValue("key2", data)); assertEquals("Should match", inner1, apiNeutralSchemaValidator.getValue("key3", data)); assertEquals("Should match", "value4", apiNeutralSchemaValidator.getValue("key3.key4", data)); assertEquals("Should match", "value5", apiNeutralSchemaValidator.getValue("key3.key5", data)); assertEquals("Should match", inner2, apiNeutralSchemaValidator.getValue("key3.key6", data)); assertEquals("Should match", "value7", apiNeutralSchemaValidator.getValue("key3.key6.key7", data)); assertEquals("Should match", "value8", apiNeutralSchemaValidator.getValue("key3.key6.key8", data)); }
### Question: DoubleSchema extends PrimitiveNumericSchema<Double> { @Override public Object convert(Object value) { if (value instanceof Integer) { return ((Integer) value).doubleValue(); } else if (value instanceof Long) { return ((Long) value).doubleValue(); } else if (value instanceof Float) { return ((Float) value).doubleValue(); } else if (value instanceof Double) { return (Double) value; } else if (value instanceof String) { try { return Double.parseDouble((String) value); } catch (NumberFormatException nfe) { throw (IllegalArgumentException) new IllegalArgumentException(value + " cannot be parsed to a double").initCause(nfe); } } throw new IllegalArgumentException(value + " is not a double"); } DoubleSchema(); @Override Object convert(Object value); }### Answer: @Test public void testConvert() throws Exception { double value = 1.2; Object convertedValue = this.schema.convert("" + value); assertTrue(convertedValue instanceof Double); Double convertedInput = (Double) convertedValue; assertTrue(convertedInput.doubleValue() == value); } @Test(expected = IllegalArgumentException.class) public void testBadConvert() { this.schema.convert("INVALID INPUT"); } @Test public void testNonConvert() { Object convertedValue = this.schema.convert(12.345); assertTrue(convertedValue instanceof Double); } @Test public void testDoubleConverter() { double data = 12.0; float floatData = (float) data; int intData = (int) data; long longData = (long) data; assertTrue("Failure returning same object", this.schema.convert(data).equals(data)); assertTrue("Failure parsing double from long", this.schema.convert(longData).equals(data)); assertTrue("Failure parsing double from integer", this.schema.convert(intData).equals(data)); assertTrue("Failure parsing double from float", this.schema.convert(floatData).equals(data)); assertTrue("Failure parsing double 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: EdOrgExtractHelper implements InitializingBean { public Map<String, Set<String>> getBulkExtractEdOrgsPerApp() { NeutralQuery appQuery = new NeutralQuery(new NeutralCriteria("applicationId", NeutralCriteria.CRITERIA_IN, getBulkExtractApps())); Iterable<Entity> apps = repository.findAll("applicationAuthorization", appQuery); Map<String, Set<String>> edorgIds = new HashMap<String, Set<String>>(); for (Entity app : apps) { Set<String> edorgs = new HashSet<String>(BulkExtractMongoDA.getAuthorizedEdOrgIds(app)); edorgIds.put((String) app.getBody().get("applicationId"), edorgs); } return edorgIds; } @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 getBulkExtractEdOrgsPerAppTest() { getBulkExtractAppsTest(); Map<String, Object> edorg1 = new HashMap<String, Object>(); edorg1.put("authorizedEdorg", "edOrg1"); Map<String, Object> edorg2 = new HashMap<String, Object>(); edorg2.put("authorizedEdorg", "edOrg2"); @SuppressWarnings("unchecked") Entity authOne = buildAuthEntity("1", Arrays.asList(edorg1, edorg2)); Entity authTwo = buildAuthEntity("5", new ArrayList<Map<String, Object>>()); List<Entity> auths = Arrays.asList(authOne, authTwo); when(repository.findAll(Mockito.eq("applicationAuthorization"), Mockito.any(NeutralQuery.class))).thenReturn(auths); Map<String, Set<String>> bulkExtractEdOrgsPerApp = helper.getBulkExtractEdOrgsPerApp(); assertTrue(bulkExtractEdOrgsPerApp.size() == 2); assertTrue(bulkExtractEdOrgsPerApp.get(authOne.getBody().get("applicationId")).containsAll( Arrays.asList("edOrg1","edOrg2"))); assertTrue(bulkExtractEdOrgsPerApp.get(authTwo.getBody().get("applicationId")).isEmpty()); }
### Question: Launcher { public void execute(String tenant, boolean isDelta) { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_INFO, BEMessageCode.BE_SE_CODE_0001)); Entity tenantEntity = bulkExtractMongoDA.getTenant(tenant); if (tenantEntity != null) { DateTime startTime = new DateTime(); if (isDelta) { LOG.info("isDelta=true ... deltaExtractor.execute()"); deltaExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } else { LOG.info("isDelta=false ... localEdOrgExtractor.execute()"); edOrgExtractor.execute(tenant, getTenantDirectory(tenant), startTime); LOG.info("Starting public data extract..."); tenantPublicDataExtractor.execute(tenant, getTenantDirectory(tenant), startTime); } } else { audit(securityEventUtil.createSecurityEvent(Launcher.class.getName(), "Bulk extract execution", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0002, tenant)); LOG.error( "A bulk extract is not being initiated for the tenant {} because the tenant has not been onboarded.", tenant); } } void execute(String tenant, boolean isDelta); static String getTimeStamp(Date date); void setBaseDirectory(String baseDirectory); static void main(String[] args); void setEdOrgExtractor(EdOrgExtractor edOrgExtractor); EdOrgExtractor getEdOrgExtractor(); void setTenantPublicDataExtractor(TenantPublicDataExtractor tenantPublicDataExtractor); BulkExtractMongoDA getBulkExtractMongoDA(); void setBulkExtractMongoDA(BulkExtractMongoDA bulkExtractMongoDA); void setSecurityEventUtil(SecurityEventUtil securityEventUtil); }### Answer: @Test public void testInvalidTenant() { String tenantId = "testTenant"; Mockito.when(bulkExtractMongoDA.getTenant(tenantId)).thenReturn(null); launcher.execute(tenantId, false); Mockito.verify(localEdOrgExtractor, Mockito.never()).execute(Mockito.eq("tenant"), Mockito.any(File.class), Mockito.any(DateTime.class)); } @Test public void testValidTenant() { String tenantId = "Midgar"; Mockito.doNothing().when(localEdOrgExtractor).execute(Mockito.eq("tenant"), Mockito.any(File.class), Mockito.any(DateTime.class)); Mockito.when(bulkExtractMongoDA.getTenant(tenantId)).thenReturn(testTenantEntity); launcher.execute(tenantId, false); Mockito.verify(localEdOrgExtractor, Mockito.times(1)).execute(Mockito.eq(tenantId), Mockito.any(File.class), Mockito.any(DateTime.class)); }
### 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: NeutralCriteria { @Override public boolean equals(Object o) { if (o instanceof NeutralCriteria) { NeutralCriteria nc = (NeutralCriteria) o; boolean keysMatch = this.valuesMatch(this.key, nc.key); boolean operatorsMatch = this.valuesMatch(this.operator, nc.operator); boolean valuesMatch = this.valuesMatch(this.value, nc.value); boolean prefixesMatch = (this.canBePrefixed == nc.canBePrefixed); boolean typeMatch = ( this.getType() == nc.getType() ); boolean removableMatch = (this.isRemovable() == nc.isRemovable()); return (keysMatch && operatorsMatch && valuesMatch && prefixesMatch && typeMatch && removableMatch); } return false; } NeutralCriteria(String criteria); NeutralCriteria(String newKey, String newOperator, Object newValue); NeutralCriteria(String newKey, String newOperator, Object newValue, boolean canBePrefixed); @SuppressWarnings("PMD.UselessOverridingMethod") // this is overridden because equals is also overridden @Override int hashCode(); String getKey(); String getOperator(); Object getValue(); void setKey(String key); void setOperator(String operator); void setValue(Object value); boolean canBePrefixed(); void setCanBePrefixed(boolean canBePrefixed); @Override String toString(); @Override boolean equals(Object o); SearchType getType(); void setType(SearchType type); boolean isRemovable(); void setRemovable(boolean removable); static final String CRITERIA_IN; static final String CRITERIA_REGEX; static final String CRITERIA_GT; static final String CRITERIA_GTE; static final String CRITERIA_LT; static final String CRITERIA_LTE; static final String OPERATOR_EQUAL; static final String CRITERIA_EXISTS; }### Answer: @Test public void testEqualsComparison() { NeutralCriteria neutralCriteria1 = new NeutralCriteria("key", "=", "value"); NeutralCriteria neutralCriteria2 = new NeutralCriteria("key", "=", "value"); NeutralCriteria neutralCriteria3 = new NeutralCriteria("differentKey", "=", "value"); NeutralCriteria neutralCriteria4 = new NeutralCriteria("key", "!=", "value"); NeutralCriteria neutralCriteria5 = new NeutralCriteria("key", "!=", "differentValue"); NeutralCriteria neutralCriteria6 = new NeutralCriteria("key", "=", "value", true); NeutralCriteria neutralCriteria7 = new NeutralCriteria("key", "=", "value", false); assertTrue(neutralCriteria1.equals(neutralCriteria2)); assertFalse(neutralCriteria1 == neutralCriteria2); assertFalse(neutralCriteria1.equals(neutralCriteria3)); assertFalse(neutralCriteria1.equals(neutralCriteria4)); assertFalse(neutralCriteria1.equals(neutralCriteria5)); assertTrue(neutralCriteria1.equals(neutralCriteria6)); assertFalse(neutralCriteria1.equals(neutralCriteria7)); }
### Question: EdOrgHierarchyHelper { public Set<Entity> getAncestorsOfEdOrg(Entity entity) { if (isSEA(entity)) { return null; } Set<String> visitedIds = new HashSet<String>(); Set<Entity> ancestors = new HashSet<Entity>(); List<Entity> stack = new ArrayList<Entity>(10); ancestors.add(entity); stack.add(entity); while (!stack.isEmpty()) { Entity cur = stack.remove(stack.size() - 1); if (visitedIds.contains(cur.getEntityId())) { continue; } else { visitedIds.add(cur.getEntityId()); } if (cur.getBody().containsKey("parentEducationAgencyReference")) { List<Entity> parentEdOrgs = getParentEdOrg(cur); if (parentEdOrgs != null) { for (Entity parent:parentEdOrgs) { stack.add(parent); if (!isSEA(parent)) { ancestors.add(parent); } } } } } return ancestors; } EdOrgHierarchyHelper(Repository<Entity> repo); boolean isSEA(Entity entity); boolean isLEA(Entity entity); boolean isSchool(Entity entity); List<Entity> getTopLEAOfEdOrg(Entity entity); Set<Entity> getAncestorsOfEdOrg(Entity entity); String getSEAOfEdOrg(Entity entity); Entity getSEA(); }### Answer: @Test public void testGetAncestorsOfEdOrgWithCycle() { Entity sea = buildEntityType(SEA); Entity lea = buildEntityType(LEA); Entity school = buildEntityType(SCHOOL); school.getBody().put(PARENT_ED_ORG_REF, Arrays.asList(lea.getEntityId())); lea.getBody().put(PARENT_ED_ORG_REF, Arrays.asList(sea.getEntityId(), school.getEntityId())); sea.getBody().put(PARENT_ED_ORG_REF, Arrays.asList()); when(repo.findById(EntityNames.EDUCATION_ORGANIZATION, sea.getEntityId())).thenReturn(sea); when(repo.findById(EntityNames.EDUCATION_ORGANIZATION, lea.getEntityId())).thenReturn(lea); when(repo.findById(EntityNames.EDUCATION_ORGANIZATION, school.getEntityId())).thenReturn(school); Set<Entity> ancestors = underTest.getAncestorsOfEdOrg(school); assertNotNull(ancestors); assertTrue("LEA must be an ancestor", ancestors.contains(lea)); assertTrue("school should be contained in the results as well, per required behavior", ancestors.contains(school)); assertEquals("unexpected ancestors", 2, ancestors.size()); }
### 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: CourseTranscriptContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); if (entity == null) { return edOrgs; } String studentId = (String) entity.getBody().get(STUDENT_ID); if (studentId != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } String studentAcademicRecordId = (String) entity.getBody().get(STUDENT_ACADEMIC_RECORD_ID); if (studentAcademicRecordId != null) { Entity studentAcademicRecord = repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordId); if (studentAcademicRecord != null) { edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentAcademicRecord.getBody().get(STUDENT_ID), entity)); } } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); static final String ED_ORG_REFERENCE; static final String STUDENT_ACADEMIC_RECORD_ID; static final String STUDENT_ID; }### Answer: @Test public void returnEmptySetIfNoStudent() { Entity courseTranscript = buildCourseTranscript(); courseTranscript.getBody().remove(STUDENT_ID); courseTranscript.getBody().remove(STUDENT_ACADEMIC_RECORD_ID); assertEquals(Collections.emptySet(), underTest.findGoverningEdOrgs(courseTranscript)); } @Test public void followStudentId() { Entity courseTranscript = buildCourseTranscript(); when(studentResolver.findGoverningEdOrgs("student1", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("toplea2"))); assertEquals(new HashSet<String>(Arrays.asList("toplea2")), underTest.findGoverningEdOrgs(courseTranscript)); } @Test public void noStudentIdFollowAcademicRecord() { Entity courseTranscript = buildCourseTranscript(); courseTranscript.getBody().remove(STUDENT_ID); when(studentResolver.findGoverningEdOrgs("student1", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("toplea2"))); assertEquals(new HashSet<String>(Arrays.asList("toplea2")), underTest.findGoverningEdOrgs(courseTranscript)); } @Test public void testDifferentEdOrgs() { Entity courseTranscript = buildCourseTranscript(); Entity studentAcademicRecord = buildStudentAcademicRecord(); studentAcademicRecord.getBody().put(STUDENT_ID, "student2"); when(repo.findById(EntityNames.STUDENT_ACADEMIC_RECORD, "studentacademicrecord1")).thenReturn(studentAcademicRecord); when(studentResolver.findGoverningEdOrgs("student1", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("edOrg1"))); when(studentResolver.findGoverningEdOrgs("student2", courseTranscript)).thenReturn(new HashSet<String>(Arrays.asList("edOrg2"))); assertEquals(new HashSet<String>(Arrays.asList("edOrg1", "edOrg2")), underTest.findGoverningEdOrgs(courseTranscript)); }
### Question: GradebookEntryContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, Query.query(Criteria.where("body.gradebookEntryId").is(entity.getEntityId()))); while(studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); edOrgs.addAll(studentResolver.findGoverningEdOrgs((String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID), entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }### Answer: @Test public void test() { Entity gradebookEntry = Mockito.mock(Entity.class); Mockito.when(gradebookEntry.getEntityId()).thenReturn("123_id"); Mockito.when(gradebookEntry.getType()).thenReturn(EntityNames.GRADEBOOK_ENTRY); Entity sgbe1 = Mockito.mock(Entity.class); Map<String, Object> body1 = new HashMap<String, Object>(); body1.put(ParameterConstants.STUDENT_ID, "student1"); Mockito.when(sgbe1.getBody()).thenReturn(body1); Entity sgbe2 = Mockito.mock(Entity.class); Map<String, Object> body2 = new HashMap<String, Object>(); body2.put(ParameterConstants.STUDENT_ID, "student2"); Mockito.when(sgbe2.getBody()).thenReturn(body2); Mockito.when(repo.findEach(eq(EntityNames.STUDENT_GRADEBOOK_ENTRY), argThat(new BaseMatcher<Query>() { @Override public boolean matches(Object item) { Query q = (Query) item; return q.getQueryObject().get("body.gradebookEntryId").equals("123_id"); } @Override public void describeTo(Description description) { } }))).thenReturn(Arrays.asList(sgbe1, sgbe2).iterator()); Mockito.when(studentResolver.findGoverningEdOrgs("student1", gradebookEntry)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea2"))); Mockito.when(studentResolver.findGoverningEdOrgs("student2", gradebookEntry)).thenReturn(new HashSet<String>(Arrays.asList("lea1", "lea3"))); Assert.assertEquals(new HashSet<String>(Arrays.asList("lea1", "lea2", "lea3")), resolver.findGoverningEdOrgs(gradebookEntry)); }
### 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: DisciplineActionContextResolver implements ContextResolver { @Override public Set<String> findGoverningEdOrgs(Entity entity) { Set<String> edOrgs = new HashSet<String>(); List<String> studentIds = (List<String>) entity.getBody().get(ParameterConstants.STUDENT_ID); for(String studentId: studentIds){ edOrgs.addAll(studentResolver.findGoverningEdOrgs(studentId, entity)); } return edOrgs; } @Override Set<String> findGoverningEdOrgs(Entity entity); }### Answer: @Test public void testSingleStudent() { Entity disciplineAction = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.STUDENT_ID, Arrays.asList("student1")); Mockito.when(disciplineAction.getBody()).thenReturn(body); Mockito.when(studentResolver.findGoverningEdOrgs("student1", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg1"))); Assert.assertEquals(new HashSet<String>(Arrays.asList("edOrg1")), resolver.findGoverningEdOrgs(disciplineAction)); } @Test public void testMultipleStudents() { Entity disciplineAction = Mockito.mock(Entity.class); Map<String, Object> body = new HashMap<String, Object>(); body.put(ParameterConstants.STUDENT_ID, Arrays.asList("student1", "student2", "student3", "student4")); Mockito.when(disciplineAction.getBody()).thenReturn(body); Mockito.when(studentResolver.findGoverningEdOrgs("student1", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg1"))); Mockito.when(studentResolver.findGoverningEdOrgs("student2", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg2", "edOrg1"))); Mockito.when(studentResolver.findGoverningEdOrgs("student3", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg3","edOrg2", "edOrg1"))); Mockito.when(studentResolver.findGoverningEdOrgs("student4", disciplineAction)).thenReturn(new HashSet<String>(Arrays.asList("edOrg4"))); Assert.assertEquals(new HashSet<String>(Arrays.asList("edOrg1", "edOrg2", "edOrg3", "edOrg4")), resolver.findGoverningEdOrgs(disciplineAction)); }
### 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: SectionEmbeddedDocsExtractor implements EntityDatedExtract { @SuppressWarnings("unchecked") @Override public void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache) { Iterator<Entity> sections = this.repository.findEach(EntityNames.SECTION, new NeutralQuery()); while (sections.hasNext()) { Entity section = sections.next(); extractTeacherSectionAssociation(section); extractGradebookEntry(section, gradebookEntryCache); extractStudentSectionAssociation(section); } } SectionEmbeddedDocsExtractor(EntityExtractor entityExtractor, ExtractFileMap leaToExtractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentCache, EntityToEdOrgDateCache staffDatedCache); @SuppressWarnings("unchecked") @Override void extractEntities(final EntityToEdOrgDateCache gradebookEntryCache); EntityToEdOrgDateCache getStudentSectionAssociationDateCache(); }### Answer: @Test public void testExtractValidTSA() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.VALIDTSA.generate(), AccessibleVia.VALIDTSA.generate(), AccessibleVia.VALIDTSA.generate(), AccessibleVia.NONE.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.times(3)).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.TEACHER_SECTION_ASSOCIATION)); } @Test public void testExtractInvalidTSAs() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.INVALIDTSA.generate(), AccessibleVia.INVALIDTSA.generate(), AccessibleVia.INVALIDTSA.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.never()).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.TEACHER_SECTION_ASSOCIATION)); } @Test public void testExtractValidSSAs() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.VALIDSSA.generate(), AccessibleVia.VALIDSSA.generate(), AccessibleVia.VALIDSSA.generate(), AccessibleVia.NONE.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.times(3)).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.eq(EntityNames.STUDENT_SECTION_ASSOCIATION)); } @Test public void testExtractInvalidSSAs() throws Exception { List<Entity> list = Arrays.asList(AccessibleVia.INVALIDSSA.generate(), AccessibleVia.INVALIDSSA.generate(), AccessibleVia.INVALIDSSA.generate()); Mockito.when(repo.findEach(Mockito.eq(EntityNames.SECTION), Mockito.any(NeutralQuery.class))).thenReturn(list.iterator()); se.extractEntities(null); Mockito.verify(ex, Mockito.never()).extractEntity(Mockito.any(Entity.class), Mockito.any(ExtractFile.class), Mockito.any(String.class)); }
### Question: StudentGradebookEntryExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STUDENT_GRADEBOOK_ENTRY, this.getClass().getName()); Iterator<Entity> studentGradebookEntries = repo.findEach(EntityNames.STUDENT_GRADEBOOK_ENTRY, new NeutralQuery()); while (studentGradebookEntries.hasNext()) { Entity studentGradebookEntry = studentGradebookEntries.next(); String studentId = (String) studentGradebookEntry.getBody().get(ParameterConstants.STUDENT_ID); String gradebookEntryId = (String) studentGradebookEntry.getBody().get(ParameterConstants.GRADEBOOK_ENTRY_ID); Map<String, DateTime> studentEdOrgs = studentCache.getEntriesById(studentId); for (Map.Entry<String, DateTime> entry: studentEdOrgs.entrySet()) { DateTime upToDate = entry.getValue(); if(shouldExtract(studentGradebookEntry, upToDate)) { extractor.extractEntity(studentGradebookEntry, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.STUDENT_GRADEBOOK_ENTRY); gradebookEntryCache.addEntry(gradebookEntryId, entry.getKey(), upToDate); } } } } StudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentCache); EntityToEdOrgDateCache getGradebookEntryCache(); }### Answer: @Test public void testExtractNoEntityBecauseOfIdMiss() { entityBody.put(ParameterConstants.STUDENT_ID, "studentId99"); Mockito.when(mockRepo.findEach(Mockito.eq("studentGradebookEntry"), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(mockStudentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq("studentGradebookEntry")); }
### Question: ParentExtractor implements EntityExtract { @Override public void extractEntities(EntityToEdOrgCache entityToEdorgCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.PARENT, this.getClass().getName()); Iterator<Entity> parents = repo.findEach(EntityNames.PARENT, new NeutralQuery()); Set<String> validParents = entityToEdorgCache.getEntityIds(); while (parents.hasNext()) { Entity parent = parents.next(); if (!validParents.contains(parent.getEntityId())) { continue; } for (String edOrg : entityToEdorgCache.getEntriesById(parent.getEntityId())) { extractor.extractEntity(parent, map.getExtractFileForEdOrg(edOrg), EntityNames.PARENT); } } } ParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgCache entityToEdorgCache); }### Answer: @Test public void testWriteOneEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); } @Test public void testWriteManyEntities() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity, mockEntity, mockEntity).iterator()); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor, Mockito.times(3)).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); } @Test public void testExtractNoEntityBecauseOfLEAMiss() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(null); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); } @Test public void testExtractNoEntityBecauseOfIdMiss() { Mockito.when(mockEntity.getEntityId()).thenReturn("parent2"); Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.PARENT), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(mockParentCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.PARENT)); }
### Question: StaffExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.STAFF, this.getClass().getName()); Iterator<Entity> staffs = repo.findEach(EntityNames.STAFF, new NeutralQuery()); while (staffs.hasNext()) { Entity staff = staffs.next(); Set<String> edOrgs = staffToEdorgDateCache.getEntriesById(staff.getEntityId()).keySet(); for (String edOrg : edOrgs) { extractor.extractEntity(staff, map.getExtractFileForEdOrg(edOrg), EntityNames.STAFF); } } } StaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache staffToEdorgDateCache); }### Answer: @Test public void testExtractOneEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.STAFF), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(staffToLeaDateCache); Mockito.verify(mockExtractor).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.STAFF)); } @Test public void testExtractManyEntity() { Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.STAFF), Mockito.eq(new NeutralQuery()))) .thenReturn(Arrays.asList(mockEntity, mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(mockFile); extractor.extractEntities(staffToLeaDateCache); Mockito.verify(mockExtractor, Mockito.times(2)).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.STAFF)); } @Test public void testExtractNoEntityBecauseOfLEAMiss() { Mockito.when(mockEntity.getEntityId()).thenReturn("Staff2"); Mockito.when(mockRepo.findEach(Mockito.eq(EntityNames.STAFF), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); Mockito.when(mockMap.getExtractFileForEdOrg("LEA")).thenReturn(null); extractor.extractEntities(staffToLeaDateCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq(EntityNames.STAFF)); }
### 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: ExtractorFactory { public ExtractFile buildEdOrgExtractFile(String path, String edOrg, String archiveName, Map<String, PublicKey> appPublicKeys, SecurityEventUtil securityEventUtil) { File directory = new File(path, edOrg); directory.mkdirs(); return new ExtractFile(directory, archiveName, appPublicKeys, securityEventUtil); } StudentExtractor buildStudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentAssessmentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); YearlyTranscriptExtractor buildYearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityExtract buildParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); StaffEdorgAssignmentExtractor buildStaffAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildTeacherSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildAttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); ExtractFile buildEdOrgExtractFile(String path, String edOrg, String archiveName, Map<String, PublicKey> appPublicKeys, SecurityEventUtil securityEventUtil); EntityDatedExtract buildStaffCohortAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); SectionEmbeddedDocsExtractor buildSectionExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentDatedCache, EdOrgExtractHelper edOrgExtractHelper, EntityToEdOrgDateCache staffDatedCache); EntityDatedExtract buildStaffProgramAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildCourseTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EntityToEdOrgDateCache studentDatedCache); StudentGradebookEntryExtractor buildStudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentCompetencyExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository); EntityDatedExtract buildDisciplineExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache entityCache); }### Answer: @Test public void testBuildExtractFile() { Assert.assertTrue(factory.buildEdOrgExtractFile("bloop", "Bleep", "BLOO BLOO", null, null) != null); Assert.assertTrue(factory.buildEdOrgExtractFile("bloop", "Bleep", "BLOOB BLOO", null, null).getClass() == ExtractFile.class); }
### Question: ExtractorFactory { public EntityDatedExtract buildAttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper) { return new AttendanceExtractor(extractor, map, repo, edOrgExtractHelper); } StudentExtractor buildStudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentAssessmentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); YearlyTranscriptExtractor buildYearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityExtract buildParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); StaffEdorgAssignmentExtractor buildStaffAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildTeacherSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildAttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); ExtractFile buildEdOrgExtractFile(String path, String edOrg, String archiveName, Map<String, PublicKey> appPublicKeys, SecurityEventUtil securityEventUtil); EntityDatedExtract buildStaffCohortAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); SectionEmbeddedDocsExtractor buildSectionExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentDatedCache, EdOrgExtractHelper edOrgExtractHelper, EntityToEdOrgDateCache staffDatedCache); EntityDatedExtract buildStaffProgramAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildCourseTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EntityToEdOrgDateCache studentDatedCache); StudentGradebookEntryExtractor buildStudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentCompetencyExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository); EntityDatedExtract buildDisciplineExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache entityCache); }### Answer: @Test public void testBuildAttendanceExtractor() { Assert.assertTrue(factory.buildAttendanceExtractor(null, null, null, null) != null); Assert.assertTrue(factory.buildAttendanceExtractor(null, null, null, null).getClass() == AttendanceExtractor.class); }
### Question: ExtractorFactory { public StudentExtractor buildStudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper) { return new StudentExtractor(extractor, map, repo, new ExtractorHelper(edOrgExtractHelper), edOrgExtractHelper); } StudentExtractor buildStudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentAssessmentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); YearlyTranscriptExtractor buildYearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityExtract buildParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); StaffEdorgAssignmentExtractor buildStaffAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildTeacherSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildAttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); ExtractFile buildEdOrgExtractFile(String path, String edOrg, String archiveName, Map<String, PublicKey> appPublicKeys, SecurityEventUtil securityEventUtil); EntityDatedExtract buildStaffCohortAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); SectionEmbeddedDocsExtractor buildSectionExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentDatedCache, EdOrgExtractHelper edOrgExtractHelper, EntityToEdOrgDateCache staffDatedCache); EntityDatedExtract buildStaffProgramAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildCourseTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EntityToEdOrgDateCache studentDatedCache); StudentGradebookEntryExtractor buildStudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentCompetencyExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository); EntityDatedExtract buildDisciplineExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache entityCache); }### Answer: @Test public void testBuildStudentExtractor() { Assert.assertTrue(factory.buildStudentExtractor(null, null, null, null) != null); Assert.assertTrue(factory.buildStudentExtractor(null, null, null, null).getClass() == StudentExtractor.class); }
### Question: ExtractorFactory { public EntityDatedExtract buildStudentAssessmentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper) { return new StudentAssessmentExtractor(extractor, map, repo, edOrgExtractHelper); } StudentExtractor buildStudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentAssessmentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); YearlyTranscriptExtractor buildYearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityExtract buildParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); StaffEdorgAssignmentExtractor buildStaffAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildTeacherSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildAttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); ExtractFile buildEdOrgExtractFile(String path, String edOrg, String archiveName, Map<String, PublicKey> appPublicKeys, SecurityEventUtil securityEventUtil); EntityDatedExtract buildStaffCohortAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); SectionEmbeddedDocsExtractor buildSectionExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentDatedCache, EdOrgExtractHelper edOrgExtractHelper, EntityToEdOrgDateCache staffDatedCache); EntityDatedExtract buildStaffProgramAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildCourseTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EntityToEdOrgDateCache studentDatedCache); StudentGradebookEntryExtractor buildStudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentCompetencyExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository); EntityDatedExtract buildDisciplineExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache entityCache); }### Answer: @Test public void testBuildStudentAssessmentExtractor() { Assert.assertTrue(factory.buildStudentAssessmentExtractor(null, null, null, null) != null); Assert.assertTrue(factory.buildStudentAssessmentExtractor(null, null, null, null).getClass() == StudentAssessmentExtractor.class); }
### Question: ExtractorFactory { public EntityDatedExtract buildStaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper) { return new StaffExtractor(extractor, map, repo, edOrgExtractHelper); } StudentExtractor buildStudentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentAssessmentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); YearlyTranscriptExtractor buildYearlyTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityExtract buildParentExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); StaffEdorgAssignmentExtractor buildStaffAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStaffExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildTeacherSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildAttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentSchoolAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); ExtractFile buildEdOrgExtractFile(String path, String edOrg, String archiveName, Map<String, PublicKey> appPublicKeys, SecurityEventUtil securityEventUtil); EntityDatedExtract buildStaffCohortAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); SectionEmbeddedDocsExtractor buildSectionExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentDatedCache, EdOrgExtractHelper edOrgExtractHelper, EntityToEdOrgDateCache staffDatedCache); EntityDatedExtract buildStaffProgramAssociationExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildCourseTranscriptExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EntityToEdOrgDateCache studentDatedCache); StudentGradebookEntryExtractor buildStudentGradebookEntryExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); EntityDatedExtract buildStudentCompetencyExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository); EntityDatedExtract buildDisciplineExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache entityCache); }### Answer: @Test public void testBuildStaffExtractor() { Assert.assertTrue(factory.buildStaffExtractor(null, null, null, null) != null); Assert.assertTrue(factory.buildStaffExtractor(null, null, null, null).getClass() == StaffExtractor.class); }
### Question: ExtractorHelper { public Set<String> fetchCurrentParentsFromStudent(Entity student) { Set<String> parents = new TreeSet<String>(); if (student.getEmbeddedData().containsKey(EntityNames.STUDENT_PARENT_ASSOCIATION)) { for (Entity assoc : student.getEmbeddedData().get(EntityNames.STUDENT_PARENT_ASSOCIATION)) { String parentId = (String) assoc.getBody().get(ParameterConstants.PARENT_ID); if (parentId != null) { parents.add(parentId); } } } return parents; } ExtractorHelper(); ExtractorHelper(EdOrgExtractHelper edOrgExtractHelper); Map<String, DateTime> fetchAllEdOrgsForStudent(Entity student); Map<String, DateTime> updateEdorgToDateMap(Map<String, Object> entityBody, Map<String, DateTime> edOrgToDate, String edOrgIdField, String beginDateField, String endDateField); void setDateHelper(DateHelper helper); Set<String> fetchCurrentParentsFromStudent(Entity student); Map<String, Collection<String>> buildSubToParentEdOrgCache(EntityToEdOrgCache edOrgCache); EdOrgExtractHelper getEdOrgExtractHelper(); void setEdOrgExtractHelper(EdOrgExtractHelper edOrgExtractHelper); }### Answer: @Test public void testFetchCurrentParentsFromStudentNullChecks() { Map<String, List<Entity>> embeddedData = new HashMap<String, List<Entity>>(); Assert.assertTrue(helper.fetchCurrentParentsFromStudent(mockEntity).size() == 0); Mockito.when(mockEntity.getEmbeddedData()).thenReturn(embeddedData); Assert.assertTrue(helper.fetchCurrentParentsFromStudent(mockEntity).size() == 0); Entity parentAssoc1 = Mockito.mock(Entity.class); Entity parentAssoc2 = Mockito.mock(Entity.class); Map<String, Object> body = Mockito.mock(Map.class); Map<String, Object> body2 = Mockito.mock(Map.class); Mockito.when(parentAssoc1.getBody()).thenReturn(body); Mockito.when(parentAssoc2.getBody()).thenReturn(body2); List<Entity> parentAssociations = Arrays.asList(parentAssoc1, parentAssoc2); embeddedData.put(EntityNames.STUDENT_PARENT_ASSOCIATION, parentAssociations); Assert.assertTrue(helper.fetchCurrentParentsFromStudent(mockEntity).size() == 0); Mockito.when(body.get(Mockito.eq(ParameterConstants.PARENT_ID))).thenReturn("ParentId123"); Mockito.when(body2.get(Mockito.eq(ParameterConstants.PARENT_ID))).thenReturn("ParentId456"); Assert.assertTrue(helper.fetchCurrentParentsFromStudent(mockEntity).size() == 2); }
### Question: ExtractorHelper { public Map<String, Collection<String>> buildSubToParentEdOrgCache(EntityToEdOrgCache edOrgCache) { Map<String, String> result = new HashMap<String, String>(); HashMultimap<String, String> map = HashMultimap.create(); for(String lea : edOrgCache.getEntityIds()) { for (String child : edOrgCache.getEntriesById(lea)) { result.put(child, lea); map.put(child, lea); } } return map.asMap(); } ExtractorHelper(); ExtractorHelper(EdOrgExtractHelper edOrgExtractHelper); Map<String, DateTime> fetchAllEdOrgsForStudent(Entity student); Map<String, DateTime> updateEdorgToDateMap(Map<String, Object> entityBody, Map<String, DateTime> edOrgToDate, String edOrgIdField, String beginDateField, String endDateField); void setDateHelper(DateHelper helper); Set<String> fetchCurrentParentsFromStudent(Entity student); Map<String, Collection<String>> buildSubToParentEdOrgCache(EntityToEdOrgCache edOrgCache); EdOrgExtractHelper getEdOrgExtractHelper(); void setEdOrgExtractHelper(EdOrgExtractHelper edOrgExtractHelper); }### Answer: @Test public void testBuildSubToParentEdOrgCache() { EntityToEdOrgCache cache = new EntityToEdOrgCache(); cache.addEntry("lea-1", "school-1"); cache.addEntry("lea-1", "school-2"); cache.addEntry("lea-1", "school-3"); cache.addEntry("lea-2", "school-4"); cache.addEntry("lea-2", "school-5"); cache.addEntry("lea-3", "school-6"); Map<String, Collection<String>> result = helper.buildSubToParentEdOrgCache(cache); Assert.assertEquals(6, result.keySet().size()); Assert.assertEquals(Sets.newHashSet("lea-1"), result.get("school-1")); Assert.assertEquals(Sets.newHashSet("lea-1"), result.get("school-2")); Assert.assertEquals(Sets.newHashSet("lea-1"), result.get("school-3")); Assert.assertEquals(Sets.newHashSet("lea-2"), result.get("school-4")); Assert.assertEquals(Sets.newHashSet("lea-2"), result.get("school-5")); Assert.assertEquals(Sets.newHashSet("lea-3"), result.get("school-6")); }
### Question: AttendanceExtractor implements EntityDatedExtract { @Override public void extractEntities(EntityToEdOrgDateCache studentCache) { edOrgExtractHelper.logSecurityEvent(map.getEdOrgs(), EntityNames.ATTENDANCE, this.getClass().getName()); Iterator<Entity> attendances = repo.findEach("attendance", new NeutralQuery()); while (attendances.hasNext()) { Entity attendance = attendances.next(); Map<String, DateTime> studentEdOrgDate = studentCache.getEntriesById((String) attendance.getBody().get("studentId")); for (Map.Entry<String, DateTime> entry: studentEdOrgDate.entrySet()) { DateTime upToDate = entry.getValue(); if (EntityDateHelper.shouldExtract(attendance, upToDate)) { extractor.extractEntity(attendance, map.getExtractFileForEdOrg(entry.getKey()), EntityNames.ATTENDANCE); } } } } AttendanceExtractor(EntityExtractor extractor, ExtractFileMap map, Repository<Entity> repo, EdOrgExtractHelper edOrgExtractHelper); @Override void extractEntities(EntityToEdOrgDateCache studentCache); }### Answer: @Test public void testWriteOneAttendance() { Mockito.when(mockRepo.findEach(Mockito.eq("attendance"), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity).iterator()); entityBody.put("studentId", "student"); entityBody.put(ParameterConstants.SCHOOL_YEAR, "2010-2011"); extractor.extractEntities(mockCache); Mockito.verify(mockExtractor).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq("attendance")); } @Test public void testWriteManyAttendances() { Mockito.when(mockRepo.findEach(Mockito.eq("attendance"), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity, mockEntity, mockEntity).iterator()); entityBody.put("studentId", "student"); entityBody.put(ParameterConstants.SCHOOL_YEAR, "2010-2011"); extractor.extractEntities(mockCache); Mockito.verify(mockExtractor, Mockito.times(3)).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq("attendance")); } @Test public void testWriteNoAttendances() { Mockito.when(mockRepo.findEach(Mockito.eq("attendance"), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity, mockEntity, mockEntity).iterator()); entityBody.put("studentId", "student"); entityBody.put(ParameterConstants.SCHOOL_YEAR, "2010-2011"); Mockito.when(mockCache.getEntriesById("student")).thenReturn(new HashMap<String, DateTime>()); extractor.extractEntities(mockCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq("attendance")); } @Test public void testWriteFutureAttendances() { Mockito.when(mockRepo.findEach(Mockito.eq("attendance"), Mockito.eq(new NeutralQuery()))).thenReturn( Arrays.asList(mockEntity, mockEntity, mockEntity).iterator()); entityBody.put("studentId", "student"); entityBody.put(ParameterConstants.SCHOOL_YEAR, "3010-3011"); extractor.extractEntities(mockCache); Mockito.verify(mockExtractor, Mockito.never()).extractEntity(Mockito.eq(mockEntity), Mockito.eq(mockFile), Mockito.eq("attendance")); }
### 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: DisciplineExtractor implements EntityDatedExtract { @Override @SuppressWarnings("unchecked") public void extractEntities(final EntityToEdOrgDateCache diCache) { extract(EntityNames.DISCIPLINE_INCIDENT, new Function<Entity, Set<String>>() { @Override public Set<String> apply(Entity input) { String id = input.getEntityId(); Map<String, DateTime> edorgDate = diCache.getEntriesById(id); Set<String> edOrgs = new HashSet<String>(); for (Map.Entry<String, DateTime> entry: edorgDate.entrySet()) { DateTime upToDate = entry.getValue(); if (shouldExtract(input, upToDate)) { edOrgs.add(entry.getKey()); } } return edOrgs; } }); extract(EntityNames.DISCIPLINE_ACTION, new Function<Entity, Set<String>>() { @Override public Set<String> apply(Entity input) { Set<String> edOrgs = new HashSet<String>(); List<String> students = (List<String>) input.getBody().get("studentId"); for (String student : students) { Map<String, DateTime> edorgDate = studentCache.getEntriesById(student); for (Map.Entry<String, DateTime> entry: edorgDate.entrySet()) { DateTime upToDate = entry.getValue(); if (shouldExtract(input, upToDate)) { edOrgs.add(entry.getKey()); } } } return edOrgs; } }); } DisciplineExtractor(EntityExtractor entityExtractor, ExtractFileMap extractFileMap, Repository<Entity> repository, EntityToEdOrgDateCache studentCache); @Override @SuppressWarnings("unchecked") void extractEntities(final EntityToEdOrgDateCache diCache); }### Answer: @Test public void testExtractDisciplineIncidentAndAction() { Entity da1 = createDisciplineAction("2009-01-01"); Entity da2 = createDisciplineAction("2010-02-13"); Mockito.when(repo.findEach(Mockito.eq("disciplineAction"), Mockito.any(NeutralQuery.class))).thenReturn(Arrays.asList(da1, da2).listIterator(0)); Entity di1 = createDisciplineIncident("2000-02-01"); Entity di2 = createDisciplineIncident("2011-02-01"); Mockito.when(repo.findEach(Mockito.eq("disciplineIncident"), Mockito.any(NeutralQuery.class))).thenReturn(Arrays.asList(di1, di2).listIterator(0)); EntityToEdOrgDateCache diCache = new EntityToEdOrgDateCache(); diCache.addEntry("marker", LEA2, DateTime.parse("2010-02-12", DateHelper.getDateTimeFormat())); diCache.addEntry(DI_ID, LEA2, DateTime.parse("2010-02-12", DateHelper.getDateTimeFormat())); disc.extractEntities(diCache); Mockito.verify(ex, Mockito.times(1)).extractEntity(Mockito.eq(da1), Mockito.any(ExtractFile.class), Mockito.eq("disciplineAction")); Mockito.verify(ex, Mockito.never()).extractEntity(Mockito.eq(da2), Mockito.any(ExtractFile.class), Mockito.eq("disciplineAction")); Mockito.verify(ex, Mockito.times(1)).extractEntity(Mockito.eq(di1), Mockito.any(ExtractFile.class), Mockito.eq("disciplineIncident")); Mockito.verify(ex, Mockito.never()).extractEntity(Mockito.eq(di2), Mockito.any(ExtractFile.class), Mockito.eq("disciplineIncident")); }
### 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: ExtractFile { public boolean generateArchive() { boolean success = true; TarArchiveOutputStream tarArchiveOutputStream = null; MultiOutputStream multiOutputStream = new MultiOutputStream(); try { for(String app : clientKeys.keySet()){ SecurityEvent event = securityEventUtil.createSecurityEvent(this.getClass().getName(), "Writing extract file to the file system", LogLevelType.TYPE_INFO, app, BEMessageCode.BE_SE_CODE_0022, app); event.setTargetEdOrgList(edorg); audit(event); multiOutputStream.addStream(getAppStream(app)); } tarArchiveOutputStream = new TarArchiveOutputStream(multiOutputStream); archiveFile(tarArchiveOutputStream, manifestFile.getFile()); File errors = errorFile.getFile(); if (errors != null) { archiveFile(tarArchiveOutputStream, errors); } for (JsonFileWriter dataFile : dataFiles.values()) { File df = dataFile.getFile(); if (df != null && df.exists()) { archiveFile(tarArchiveOutputStream, df); } } } catch (Exception e) { SecurityEvent event = securityEventUtil.createSecurityEvent(this.getClass().getName(), "Writing extract file to the file system", LogLevelType.TYPE_ERROR, BEMessageCode.BE_SE_CODE_0023); event.setTargetEdOrgList(edorg); audit(event); LOG.error("Error writing to tar file: {}", e.getMessage()); success = false; for(File archiveFile : archiveFiles.values()){ FileUtils.deleteQuietly(archiveFile); } } finally { IOUtils.closeQuietly(tarArchiveOutputStream); FileUtils.deleteQuietly(tempDir); } return success; } ExtractFile(File parentDir, String archiveName, Map<String, PublicKey> clientKeys, SecurityEventUtil securityEventUtil); JsonFileWriter getDataFileEntry(String filePrefix); void closeWriters(); ManifestFile getManifestFile(); ErrorFile getErrorLogger(); boolean generateArchive(); boolean finalizeExtraction(DateTime startTime); String getFileName(String appId); Map<String, File> getArchiveFiles(); Map<String, PublicKey> getClientKeys(); void setClientKeys(Map<String, PublicKey> clientKeys); String getEdorg(); void setEdorg(String edorg); }### Answer: @Test public void generateArchiveTest() throws Exception { String fileName = archiveFile.getFileName(testApp); archiveFile.generateArchive(); TarArchiveInputStream tarInputStream = null; List<String> names = new ArrayList<String>(); File decryptedFile = null; try { decryptedFile = decrypt(new File(fileName)); tarInputStream = new TarArchiveInputStream(new FileInputStream(decryptedFile)); TarArchiveEntry entry = null; while((entry = tarInputStream.getNextTarEntry())!= null) { names.add(entry.getName()); } } finally { IOUtils.closeQuietly(tarInputStream); } Assert.assertEquals(2, names.size()); Assert.assertTrue("Student extract file not found", names.get(1).contains("student")); Assert.assertTrue("Metadata file not found", names.get(0).contains("metadata")); FileUtils.deleteQuietly(decryptedFile); }
### 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: EntityWriterManager { public Entity write(Entity entity, ExtractFile archiveFile) { writeEntityFile(entity, archiveFile); writerCollectionFile(entity, archiveFile); return entity; } Entity write(Entity entity, ExtractFile archiveFile); void writeDeleteFile(Entity entity, ExtractFile archiveFile); void setWriters(DefaultHashMap<String, EntityWriter> writers); void setMultiFileEntities(Map<String, String> multiFileEntities); void setEntities(Map<String, String> entities); }### Answer: @Test public void testWrite() { ExtractFile archiveFile = Mockito.mock(ExtractFile.class); JsonFileWriter jsonFile = Mockito.mock(JsonFileWriter.class); Mockito.when(archiveFile.getDataFileEntry(Mockito.anyString())).thenReturn(jsonFile); Entity entity = Mockito.mock(Entity.class); Mockito.when(entity.getType()).thenReturn("teacher"); writer.write(entity, archiveFile); Mockito.verify(jsonWriter1, Mockito.times(1)).write(Mockito.any(Entity.class), Mockito.any(JsonFileWriter.class), Mockito.any(ErrorFile.class)); Mockito.verify(jsonWriter2, Mockito.times(1)).write(Mockito.any(Entity.class), Mockito.any(JsonFileWriter.class), Mockito.any(ErrorFile.class)); } @Test public void testWriteDefault() { ExtractFile archiveFile = Mockito.mock(ExtractFile.class); JsonFileWriter jsonFile = Mockito.mock(JsonFileWriter.class); Mockito.when(archiveFile.getDataFileEntry(Mockito.anyString())).thenReturn(jsonFile); Entity entity = Mockito.mock(Entity.class); Mockito.when(entity.getType()).thenReturn("student"); writer.write(entity, archiveFile); Mockito.verify(defaultWriter, Mockito.times(1)).write(Mockito.any(Entity.class), Mockito.any(JsonFileWriter.class), Mockito.any(ErrorFile.class)); Mockito.verify(jsonWriter1, Mockito.times(0)).write(Mockito.any(Entity.class), Mockito.any(JsonFileWriter.class), Mockito.any(ErrorFile.class)); Mockito.verify(jsonWriter2, Mockito.times(0)).write(Mockito.any(Entity.class), Mockito.any(JsonFileWriter.class), Mockito.any(ErrorFile.class)); }
### 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: BulkExtract { @GET @Path("extract") @RightsAllowed({ Right.BULK_EXTRACT }) public Response get(@Context HttpServletRequest request) throws Exception { LOG.info("Received request to stream sample bulk extract..."); logSecurityEvent("Received request to stream sample bulk extract"); validateRequestCertificate(request); final InputStream is = this.getClass().getResourceAsStream("/bulkExtractSampleData/" + SAMPLED_FILE_NAME); StreamingOutput out = new StreamingOutput() { @Override public void write(OutputStream output) throws IOException, WebApplicationException { int n; byte[] buffer = new byte[1024]; while ((n = is.read(buffer)) > -1) { output.write(buffer, 0, n); } } }; ResponseBuilder builder = Response.ok(out); builder.header("content-disposition", "attachment; filename = " + SAMPLED_FILE_NAME); builder.header("last-modified", "Not Specified"); logSecurityEvent("Successful request to stream sample bulk extract"); return builder.build(); } @GET @Path("extract") @RightsAllowed({ Right.BULK_EXTRACT }) Response get(@Context HttpServletRequest request); @GET @Path("extract/{edOrgId}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getEdOrgExtract(@Context HttpContext context, @Context HttpServletRequest request, @PathParam("edOrgId") String edOrgId); @GET @Path("extract/public") @RightsAllowed({ Right.BULK_EXTRACT }) Response getPublicExtract(@Context HttpContext context, @Context HttpServletRequest request); @GET @Path("extract/list") @RightsAllowed({ Right.BULK_EXTRACT }) Response getBulkExtractList(@Context HttpServletRequest request, @Context HttpContext context); @GET @Path("extract/{edOrgId}/delta/{date}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getDelta(@Context HttpServletRequest request, @Context HttpContext context, @PathParam("edOrgId") String edOrgId, @PathParam("date") String date); @GET @Path("extract/public/delta/{date}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getPublicDelta(@Context HttpServletRequest request, @Context HttpContext context, @PathParam("date") String date); Repository<Entity> getMongoEntityRepository(); void setMongoEntityRepository(Repository<Entity> mongoEntityRepository); void setEdorgValidator(GenericToEdOrgValidator validator); void setFileResource(FileResource fileResource); static final String BULK_EXTRACT_FILES; static final String BULK_EXTRACT_FILE_PATH; static final String BULK_EXTRACT_DATE; static final DateTimeFormatter DATE_TIME_FORMATTER; }### Answer: @Test public void testGetSampleExtract() throws Exception { injector.setEducatorContext(); ResponseImpl res = (ResponseImpl) bulkExtract.get(req); assertEquals(200, res.getStatus()); MultivaluedMap<String, Object> headers = res.getMetadata(); assertNotNull(headers); assertTrue(headers.containsKey("content-disposition")); assertTrue(headers.containsKey("last-modified")); String header = (String) headers.getFirst("content-disposition"); assertNotNull(header); assertTrue(header.startsWith("attachment")); assertTrue(header.indexOf("sample-extract.tar") > 0); Object entity = res.getEntity(); assertNotNull(entity); StreamingOutput out = (StreamingOutput) entity; File file = new File("out.zip"); FileOutputStream os = new FileOutputStream(file); out.write(os); os.flush(); assertTrue(file.exists()); assertEquals(798669192L, FileUtils.checksumCRC32(file)); FileUtils.deleteQuietly(file); }
### Question: BulkExtract { @GET @Path("extract/list") @RightsAllowed({ Right.BULK_EXTRACT }) public Response getBulkExtractList(@Context HttpServletRequest request, @Context HttpContext context) throws Exception { LOG.info("Received request for list of links for all edOrgs and public data for this user/app"); logSecurityEvent("Received request for list of links for all edOrgs and public data for this user/app"); validateRequestAndApplicationAuthorization(request); logSecurityEvent("Successful request for list of links for all edOrgs and public data for this user/app"); return getPublicAndEdOrgListResponse(context); } @GET @Path("extract") @RightsAllowed({ Right.BULK_EXTRACT }) Response get(@Context HttpServletRequest request); @GET @Path("extract/{edOrgId}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getEdOrgExtract(@Context HttpContext context, @Context HttpServletRequest request, @PathParam("edOrgId") String edOrgId); @GET @Path("extract/public") @RightsAllowed({ Right.BULK_EXTRACT }) Response getPublicExtract(@Context HttpContext context, @Context HttpServletRequest request); @GET @Path("extract/list") @RightsAllowed({ Right.BULK_EXTRACT }) Response getBulkExtractList(@Context HttpServletRequest request, @Context HttpContext context); @GET @Path("extract/{edOrgId}/delta/{date}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getDelta(@Context HttpServletRequest request, @Context HttpContext context, @PathParam("edOrgId") String edOrgId, @PathParam("date") String date); @GET @Path("extract/public/delta/{date}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getPublicDelta(@Context HttpServletRequest request, @Context HttpContext context, @PathParam("date") String date); Repository<Entity> getMongoEntityRepository(); void setMongoEntityRepository(Repository<Entity> mongoEntityRepository); void setEdorgValidator(GenericToEdOrgValidator validator); void setFileResource(FileResource fileResource); static final String BULK_EXTRACT_FILES; static final String BULK_EXTRACT_FILE_PATH; static final String BULK_EXTRACT_DATE; static final DateTimeFormatter DATE_TIME_FORMATTER; }### Answer: @Test(expected = AccessDeniedException.class) public void testGetSLEAListFalseAppAuth() throws Exception { injector.setEducatorContext(); Entity mockEntity = mockApplicationEntity(); mockEntity.getBody().put("isBulkExtract", false); bulkExtract.getBulkExtractList(req, CONTEXT); } @Test(expected = AccessDeniedException.class) public void testGetSLEAListCheckUserAssociatedSLEAsFailure() throws Exception { injector.setEducatorContext(); mockApplicationEntity(); bulkExtract.getBulkExtractList(req, CONTEXT); } @Test() public void testGetLEAListNoUserAssociatedLEAs() throws Exception { injector.setEducatorContext(); mockApplicationEntity(); Mockito.when(edOrgHelper.getUserEdorgs(Mockito.any(Entity.class))).thenReturn(Arrays.asList("123")); Response res = bulkExtract.getBulkExtractList(req, CONTEXT); assertEquals(404, res.getStatus()); }
### 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: BulkExtract { @GET @Path("extract/public") @RightsAllowed({ Right.BULK_EXTRACT }) public Response getPublicExtract(@Context HttpContext context, @Context HttpServletRequest request) { logSecurityEvent("Received request to stream public data"); validateRequestCertificate(request); return getPublicExtractResponse(context.getRequest(), null); } @GET @Path("extract") @RightsAllowed({ Right.BULK_EXTRACT }) Response get(@Context HttpServletRequest request); @GET @Path("extract/{edOrgId}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getEdOrgExtract(@Context HttpContext context, @Context HttpServletRequest request, @PathParam("edOrgId") String edOrgId); @GET @Path("extract/public") @RightsAllowed({ Right.BULK_EXTRACT }) Response getPublicExtract(@Context HttpContext context, @Context HttpServletRequest request); @GET @Path("extract/list") @RightsAllowed({ Right.BULK_EXTRACT }) Response getBulkExtractList(@Context HttpServletRequest request, @Context HttpContext context); @GET @Path("extract/{edOrgId}/delta/{date}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getDelta(@Context HttpServletRequest request, @Context HttpContext context, @PathParam("edOrgId") String edOrgId, @PathParam("date") String date); @GET @Path("extract/public/delta/{date}") @RightsAllowed({ Right.BULK_EXTRACT }) Response getPublicDelta(@Context HttpServletRequest request, @Context HttpContext context, @PathParam("date") String date); Repository<Entity> getMongoEntityRepository(); void setMongoEntityRepository(Repository<Entity> mongoEntityRepository); void setEdorgValidator(GenericToEdOrgValidator validator); void setFileResource(FileResource fileResource); static final String BULK_EXTRACT_FILES; static final String BULK_EXTRACT_FILE_PATH; static final String BULK_EXTRACT_DATE; static final DateTimeFormatter DATE_TIME_FORMATTER; }### Answer: @Test public void testPublicExtract() throws IOException, ParseException { injector.setOauthAuthenticationWithEducationRole(); mockApplicationEntity(); Entity mockedEntity = mockBulkExtractEntity(null); Mockito.when(edOrgHelper.byId(eq("ONE"))).thenReturn(mockedEntity); Response res = bulkExtract.getPublicExtract(CONTEXT, req); assertEquals(200, res.getStatus()); MultivaluedMap<String, Object> headers = res.getMetadata(); assertNotNull(headers); assertTrue(headers.containsKey("content-disposition")); assertTrue(headers.containsKey("last-modified")); String header = (String) headers.getFirst("content-disposition"); assertNotNull(header); assertTrue(header.startsWith("attachment")); assertTrue(header.indexOf(INPUT_FILE_NAME) > 0); Object entity = res.getEntity(); assertNotNull(entity); StreamingOutput out = (StreamingOutput) entity; ByteArrayOutputStream os = new ByteArrayOutputStream(); out.write(os); os.flush(); byte[] responseData = os.toByteArray(); String s = new String(responseData); assertEquals(BULK_DATA, s); }
### Question: ResourceUtil { public static String getApiVersion(final UriInfo uriInfo) { if (uriInfo != null) { String uriPath = uriInfo.getPath(); if (uriPath != null) { int indexOfSlash = uriPath.indexOf("/"); if (indexOfSlash >= 0) { String version = uriPath.substring(0, indexOfSlash); return version; } else { return uriPath; } } } return null; } static String getApiVersion(final UriInfo uriInfo); @Deprecated static List<EmbeddedLink> getSelfLink(final UriInfo uriInfo, final String userId, final EntityDefinition defn); static EmbeddedLink getSelfLinkForEntity(final UriInfo uriInfo, final String entityId, final EntityDefinition defn); static EmbeddedLink getCustomLink(final UriInfo uriInfo, final String entityId, final EntityDefinition defn); @Deprecated static List<EmbeddedLink> getAssociationsLinks(final EntityDefinitionStore entityDefs, final EntityDefinition defn, final String id, final UriInfo uriInfo); static List<EmbeddedLink> getLinks(final EntityDefinitionStore entityDefs, final EntityDefinition defn, final EntityBody entityBody, final UriInfo uriInfo); static List<EmbeddedLink> getAggregateLink(final UriInfo uriInfo); static void putValue(MultivaluedMap<String, String> queryParameters, String key, String value); static void putValue(MultivaluedMap<String, String> queryParameters, String key, int value); static Map<String, String> convertToMap(Map<String, List<String>> map); static URI getURI(UriInfo uriInfo, String... paths); static String getVersionedUriString(UriInfo uriInfo, String... paths); static SLIPrincipal getSLIPrincipalFromSecurityContext(); static String getLinkName(String resourceName, String referenceName, String referenceField, boolean isReferenceEntity); }### Answer: @Test public void testGetApiVersionSolo() { String version = "foo"; String uriPath = version + "/bar"; UriInfo uriInfo = mock(UriInfo.class); when(uriInfo.getPath()).thenReturn(uriPath); assertTrue(ResourceUtil.getApiVersion(uriInfo).equals(version)); } @Test public void testGetApiVersionNothingElse() { String version = "foo"; UriInfo uriInfo = mock(UriInfo.class); when(uriInfo.getPath()).thenReturn(version); assertTrue(ResourceUtil.getApiVersion(uriInfo).equals(version)); }
### Question: ResourceUtil { public static EmbeddedLink getSelfLinkForEntity(final UriInfo uriInfo, final String entityId, final EntityDefinition defn) { return new EmbeddedLink(ResourceConstants.SELF, getURI(uriInfo, getApiVersion(uriInfo), PathConstants.TEMP_MAP.get(defn.getResourceName()), entityId).toString()); } static String getApiVersion(final UriInfo uriInfo); @Deprecated static List<EmbeddedLink> getSelfLink(final UriInfo uriInfo, final String userId, final EntityDefinition defn); static EmbeddedLink getSelfLinkForEntity(final UriInfo uriInfo, final String entityId, final EntityDefinition defn); static EmbeddedLink getCustomLink(final UriInfo uriInfo, final String entityId, final EntityDefinition defn); @Deprecated static List<EmbeddedLink> getAssociationsLinks(final EntityDefinitionStore entityDefs, final EntityDefinition defn, final String id, final UriInfo uriInfo); static List<EmbeddedLink> getLinks(final EntityDefinitionStore entityDefs, final EntityDefinition defn, final EntityBody entityBody, final UriInfo uriInfo); static List<EmbeddedLink> getAggregateLink(final UriInfo uriInfo); static void putValue(MultivaluedMap<String, String> queryParameters, String key, String value); static void putValue(MultivaluedMap<String, String> queryParameters, String key, int value); static Map<String, String> convertToMap(Map<String, List<String>> map); static URI getURI(UriInfo uriInfo, String... paths); static String getVersionedUriString(UriInfo uriInfo, String... paths); static SLIPrincipal getSLIPrincipalFromSecurityContext(); static String getLinkName(String resourceName, String referenceName, String referenceField, boolean isReferenceEntity); }### Answer: @Test public void testGetApiVersionLinked() { String version = "bar"; String uriPath = version + "/foo"; UriInfo uriInfo = mock(UriInfo.class); when(uriInfo.getPath()).thenReturn(uriPath); when(uriInfo.getBaseUriBuilder()).thenReturn(this.createUriBuilder()); EntityDefinition defn = mock(EntityDefinition.class); String resourceName = "baz"; when(defn.getResourceName()).thenReturn(resourceName); String entityId = "entityId"; PathConstants.TEMP_MAP.put(resourceName, resourceName); EmbeddedLink embeddedLink = ResourceUtil.getSelfLinkForEntity(uriInfo, entityId, defn); String href = embeddedLink.getHref(); assertTrue(href.contains(version + "/" + resourceName + "/" + entityId)); }
### Question: InProcessDateQueryEvaluator { public boolean entitySatisfiesDateQuery(EntityBody entity, NeutralQuery query) { for (NeutralCriteria andCriteria : query.getCriteria()) { String fieldName = andCriteria.getKey(); String operator = andCriteria.getOperator(); if (NeutralCriteria.CRITERIA_EXISTS.equals(operator)) { boolean shouldExist = (Boolean) andCriteria.getValue(); Object actualValue = entity.get(fieldName); if (shouldExist && actualValue == null) { return false; } else if (!shouldExist && actualValue != null) { return false; } } else { String fieldValue = (String) entity.get(fieldName); if (fieldValue == null) { return false; } String expectedValue = (String) andCriteria.getValue(); int comparison = fieldValue.compareTo(expectedValue); if (NeutralCriteria.CRITERIA_LT.equals(operator)) { if (comparison >= 0) { return false; } } else if (NeutralCriteria.CRITERIA_LTE.equals(operator)) { if (comparison > 0) { return false; } } else if (NeutralCriteria.CRITERIA_GT.equals(operator)) { if (comparison <= 0) { return false; } } else if (NeutralCriteria.CRITERIA_GTE.equals(operator)) { if (comparison < 0) { return false; } } } } if (query.getOrQueries().size() > 0) { for (NeutralQuery orQuery : query.getOrQueries()) { if (entitySatisfiesDateQuery(entity, orQuery)) { return true; } } return false; } else { return true; } } boolean entitySatisfiesDateQuery(EntityBody entity, NeutralQuery query); }### Answer: @Test public void shouldVerifyMissingFieldReturnsFalse() { EntityBody entity = new EntityBody(); NeutralQuery query = new NeutralQuery(); query.addCriteria(new NeutralCriteria("foo", NeutralCriteria.CRITERIA_EXISTS, true)); boolean result = eval.entitySatisfiesDateQuery(entity, query); Assert.assertEquals("Should match", false, result); } @Test public void shouldVerifyOrQueryReturnsFalse(){ EntityBody entity = new EntityBody(); entity.put("date", "2005"); NeutralQuery query = new NeutralQuery(); query.addOrQuery(createQuery(new NeutralCriteria("date",NeutralCriteria.CRITERIA_GT,"2007"))); boolean result = eval.entitySatisfiesDateQuery(entity, query); Assert.assertEquals("Should match", false, result); } @Test public void shouldVerifyOrQueryReturnsTrue(){ EntityBody entity = new EntityBody(); entity.put("date", "2005"); NeutralQuery query = new NeutralQuery(); query.addOrQuery(createQuery(new NeutralCriteria("date",NeutralCriteria.CRITERIA_GT,"2007"))); query.addOrQuery(createQuery(new NeutralCriteria("date",NeutralCriteria.CRITERIA_GT,"2001"))); boolean result = eval.entitySatisfiesDateQuery(entity, query); Assert.assertEquals("Should match", true, result); }
### 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: SecuritySessionResource { @GET @Path("check") public Object sessionCheck() { final Map<String, Object> sessionDetails = new TreeMap<String, Object>(); if (isAuthenticated(SecurityContextHolder.getContext())) { sessionDetails.put("authenticated", true); SLIPrincipal principal = (SLIPrincipal) SecurityContextHolder.getContext().getAuthentication() .getPrincipal(); sessionDetails.put("user_id", principal.getId()); sessionDetails.put("full_name", principal.getName()); sessionDetails.put("granted_authorities", principal.getRoles()); sessionDetails.put("realm", principal.getRealm()); sessionDetails.put("edOrg", principal.getEdOrg()); sessionDetails.put("edOrgId", principal.getEdOrgId()); sessionDetails.put("sliRoles", principal.getRoles()); sessionDetails.put("tenantId", principal.getTenantId()); sessionDetails.put("external_id", principal.getExternalId()); sessionDetails.put("email", getUserEmail(principal)); sessionDetails.put("rights", SecurityContextHolder.getContext().getAuthentication().getAuthorities()); sessionDetails.put("selfRights", principal.getSelfRights()); sessionDetails.put("adminRealmAuthenticated", principal.isAdminRealmAuthenticated()); sessionDetails.put("isAdminUser", principal.isAdminUser()); sessionDetails.put("userType", principal.getEntity().getType()); sessionDetails.put("edOrgRoles", principal.getEdOrgRoles()); sessionDetails.put("edOrgRights", principal.getEdOrgRights()); if (principal.getFirstName() != null) { sessionDetails.put("first_name", principal.getFirstName()); } if (principal.getLastName() != null) { sessionDetails.put("last_name", principal.getLastName()); } if (principal.getVendor() != null) { sessionDetails.put("vendor", principal.getVendor()); } } else { sessionDetails.put("authenticated", false); sessionDetails.put("redirect_user", realmPage); } return sessionDetails; } @GET @Path("logout") Map<String, Object> logoutUser(@Context HttpHeaders headers, @Context UriInfo uriInfo); @GET @Path("debug") SecurityContext sessionDebug(); @GET @Path("check") Object sessionCheck(); }### Answer: @Test public void testSessionEmails() throws Exception { buildWithEmailType(Arrays.asList("Work")); Map<String, Object> response = (Map<String, Object>) resource.sessionCheck(); assertEquals("[email protected]", response.get("email")); buildWithEmailType(Arrays.asList("Organization")); response = (Map<String, Object>) resource.sessionCheck(); assertEquals("[email protected]", response.get("email")); buildWithEmailType(Arrays.asList("Organization", "Work", "Other")); response = (Map<String, Object>) resource.sessionCheck(); assertEquals("[email protected]", response.get("email")); buildWithEmailType(Arrays.asList("Organization", "Other")); response = (Map<String, Object>) resource.sessionCheck(); assertEquals("[email protected]", response.get("email")); EntityBody body = new EntityBody(); body.put("name", new ArrayList<String>()); Entity e = Mockito.mock(Entity.class); Mockito.when(e.getBody()).thenReturn(body); injector.setCustomContext("MerpTest", "Merp Test", "IL", Arrays.asList(SecureRoleRightAccessImpl.EDUCATOR), e, "merpmerpmerp"); response = (Map<String, Object>) resource.sessionCheck(); assertNull(response.get("email")); }
### Question: RealmResource { protected Response validateArtifactResolution(String artifactResolutionEndpoint, String sourceId) { if (artifactResolutionEndpoint == null && sourceId == null) { return null; } Map<String, String> res = new HashMap<String, String>(); if (artifactResolutionEndpoint != null && sourceId != null) { if ((artifactResolutionEndpoint.isEmpty() && sourceId.isEmpty()) \|\| (sourceId.length() == SOURCEID_LENGTH && !artifactResolutionEndpoint.isEmpty())) { return null; } else { res.put(RESPONSE, "Source id needs to be 40 characters long"); } } else { res.put(RESPONSE, "artifactResolutionEndpoint and sourceId need to be present together."); } return Response.status(Status.BAD_REQUEST).entity(res).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 testvalidateArtifactResolution() { Response res = resource.validateArtifactResolution(null, null); Assert.assertNull(res); res = resource.validateArtifactResolution("", ""); Assert.assertNull(res); res = resource.validateArtifactResolution("testEndpoint", "ccf4f3895f6e37896e7511ed1d991b1d96f04ac1"); Assert.assertNull(res); res = resource.validateArtifactResolution("", "ccf4f3895f6e37896e7511ed1d991b1d96f04ac1"); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), res.getStatus()); res = resource.validateArtifactResolution("testEndpoint", ""); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), res.getStatus()); res = resource.validateArtifactResolution(null, "ccf4f3895f6e37896e7511ed1d991b1d96f04ac1"); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), res.getStatus()); res = resource.validateArtifactResolution("tesetEndpoint", null); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), res.getStatus()); res = resource.validateArtifactResolution("tesetEndpoint", "ccf4f3895f6e37896e7511ed1d991b1d96f"); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), res.getStatus()); }
### 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: SamlFederationResource { @GET @Path("sso/artifact") public Response processArtifactBinding(@Context HttpServletRequest request, @Context UriInfo uriInfo) { String artifact = request.getParameter("SAMLart"); String realmId = request.getParameter("RelayState"); if (artifact == null) { throw new APIAccessDeniedException("No artifact provided by the IdP"); } String artifactUrl = samlHelper.getArtifactUrl(realmId, artifact); ArtifactResolve artifactResolve = artifactBindingHelper.generateArtifactResolveRequest(artifact, dsPKEntry, artifactUrl); Envelope soapEnvelope = artifactBindingHelper.generateSOAPEnvelope(artifactResolve); XMLObject response = soapHelper.sendSOAPCommunication(soapEnvelope, artifactUrl, clientCertPKEntry); ArtifactResponse artifactResponse = (ArtifactResponse)((EnvelopeImpl) response).getBody().getUnknownXMLObjects().get(0); org.opensaml.saml2.core.Response samlResponse = (org.opensaml.saml2.core.Response) artifactResponse.getMessage(); return processSAMLResponse(samlResponse, uriInfo); } @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: @Test (expected= APIAccessDeniedException.class) public void processArtifactBindingInvalidRequest() { setRealm(false); HttpServletRequest request = Mockito.mock(HttpServletRequest.class); UriInfo uriInfo = Mockito.mock(UriInfo.class); Mockito.when(request.getParameter("RelayState")).thenReturn("My Realm"); resource.processArtifactBinding(request, uriInfo); } @Test public void processArtifactBindingInvalidCondition() throws URISyntaxException { setRealm(false); HttpServletRequest request = Mockito.mock(HttpServletRequest.class); UriInfo uriInfo = Mockito.mock(UriInfo.class); URI uri = new URI(issuerString); Mockito.when(uriInfo.getRequestUri()).thenReturn(uri); Mockito.when(uriInfo.getAbsolutePath()).thenReturn(uri); Mockito.when(request.getParameter("SAMLart")).thenReturn("AAQAAjh3bwgbBZ+LiIx3/RVwDGy0aRUu+xxuNtTZVbFofgZZVCKJQwQNQ7Q="); Mockito.when(request.getParameter("RelayState")).thenReturn("My Realm"); List<Assertion> assertions = new ArrayList<Assertion>(); DateTimeFormatter fmt = DateTimeFormat.forPattern("MM/dd/yyyy"); DateTime datetime = DateTime.now(); datetime = datetime.plusMonths(2) ; Assertion assertion = createAssertion(datetime.toString(fmt), "01/10/2011", issuerString); assertions.add(assertion); Mockito.when(samlHelper.getAssertion(Mockito.any(org.opensaml.saml2.core.Response.class), Mockito.any(KeyStore.PrivateKeyEntry.class))).thenReturn(assertion); expectedException.expect(APIAccessDeniedException.class); expectedException.expectMessage("Authorization could not be verified."); resource.processArtifactBinding(request, uriInfo); Mockito.when(assertion.getSubject()).thenReturn(null); resource.processArtifactBinding(request, uriInfo); assertions.clear(); assertions.add(createAssertion("01/10/2011", datetime.toString(fmt), issuerString)); resource.processArtifactBinding(request, uriInfo); }
### 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: CustomRoleResource { @GET @Path("{id}") @RightsAllowed({Right.CRUD_ROLE }) public Response read(@PathParam("id") String id, @Context final UriInfo uriInfo) { EntityBody customRole = service.get(id); String realmId = (String)customRole.get("realmId"); if (!realmHelper.getAssociatedRealmIds().contains(realmId)) { auditSecEvent(uriInfo, "Failed to read custom role with id: " + id + " wrong tenant + realm combination.",realmId); return Response.status(Status.FORBIDDEN).entity(ERROR_FORBIDDEN).build(); } return Response.ok(customRole).build(); } @PostConstruct void init(); @GET @RightsAllowed({Right.CRUD_ROLE }) Response readAll(@Context final UriInfo uriInfo, @DefaultValue("") @QueryParam("realmId") String realmId); @GET @Path("{id}") @RightsAllowed({Right.CRUD_ROLE }) Response read(@PathParam("id") String id, @Context final UriInfo uriInfo); @POST @RightsAllowed({Right.CRUD_ROLE }) Response createCustomRole(EntityBody newCustomRole, @Context final UriInfo uriInfo); @PUT @Path("{id}") @RightsAllowed({Right.CRUD_ROLE }) Response updateCustomRole(@PathParam("id") String id, EntityBody updated, @Context final UriInfo uriInfo); @DELETE @Path("{id}") @RightsAllowed({Right.CRUD_ROLE }) Response deleteCustomRole(@PathParam("id") String id, @Context final UriInfo uriInfo); static final String RESOURCE_NAME; }### Answer: @Test public void testReadAccessible() { setRealms(REALM_ID); EntityBody body = getValidRoleDoc(); String id = "old-id"; Mockito.when(service.get(id)).thenReturn((EntityBody) body.clone()); mockGetRealmId(); Response res = resource.read(id, uriInfo); Assert.assertEquals(200, res.getStatus()); Assert.assertEquals(body, res.getEntity()); } @Test public void testReadInaccessible() { String inaccessibleId = "inaccessible-id"; EntityBody body = getValidRoleDoc(); body.put("realmId", "BAD-REALM"); Mockito.when(service.get(inaccessibleId)).thenReturn(body); Response res = resource.read(inaccessibleId, uriInfo); Assert.assertEquals(403, res.getStatus()); Assert.assertEquals(CustomRoleResource.ERROR_FORBIDDEN, res.getEntity()); }

Subsets and Splits

No saved queries yet

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