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: SamlHelper { protected boolean isAssertionEncrypted(org.opensaml.saml2.core.Response samlResponse) { if (samlResponse.getEncryptedAssertions() != null && samlResponse.getEncryptedAssertions().size() != 0) { return true; } return false; } @PostConstruct void init(); Pair<String, String> createSamlAuthnRequestForRedirect(String destination, boolean forceAuthn, int idpType); org.w3c.dom.Document parseToDoc(String data); String decodeSAMLPostResponse(String encodedReponse); Signature getDigitalSignature(KeyStore.PrivateKeyEntry keystoreEntry); void validateSignature(Response samlResponse, Assertion assertion); LinkedMultiValueMap<String, String> extractAttributesFromResponse(Assertion samlAssertion); String getArtifactUrl(String realmId, String artifact); org.opensaml.saml2.core.Response convertToSAMLResponse(org.w3c.dom.Element element); Assertion getAssertion(org.opensaml.saml2.core.Response samlResponse, KeyStore.PrivateKeyEntry keystoreEntry); void validateStatus(org.opensaml.saml2.core.Response samlResponse); static final Namespace SAML_NS; static final Namespace SAMLP_NS; }### Answer: @Test public void testIsAssertionEncrypted() { Response samlResponse = Mockito.mock(Response.class); Mockito.when(samlResponse.getEncryptedAssertions()).thenReturn(null); boolean result = samlHelper.isAssertionEncrypted(samlResponse); Assert.assertFalse(result); Mockito.when(samlResponse.getEncryptedAssertions()).thenReturn(new ArrayList<EncryptedAssertion>()); result = samlHelper.isAssertionEncrypted(samlResponse); Assert.assertFalse(result); EncryptedAssertion encryptedAssertion = Mockito.mock(EncryptedAssertion.class); List<EncryptedAssertion> assertionList = new ArrayList<EncryptedAssertion>(); assertionList.add(encryptedAssertion); Mockito.when(samlResponse.getEncryptedAssertions()).thenReturn(assertionList); result = samlHelper.isAssertionEncrypted(samlResponse); Assert.assertTrue(result); }
### Question: ContextValidator implements ApplicationContextAware { protected Set<String> getEntityIdsToValidateForgiving(Collection<Entity> entities, boolean isTransitive){ Set<String> entityIdsToValidate = new HashSet<String>(); for (Entity ent : entities) { if (isOrphanCreatedByUser(ent)) { LOG.debug("Entity is orphaned: id {} of type {}", ent.getEntityId(), ent.getType()); } else if (SecurityUtil.getSLIPrincipal().getEntity() != null && SecurityUtil.getSLIPrincipal().getEntity().getEntityId().equals(ent.getEntityId())) { LOG.debug("Entity is themselves: id {} of type {}", ent.getEntityId(), ent.getType()); } else { try{ if (ownership.canAccess(ent, isTransitive)) { entityIdsToValidate.add(ent.getEntityId()); } } catch (AccessDeniedException aex) { LOG.error(aex.getMessage()); } } } return entityIdsToValidate; } @Override void setApplicationContext(ApplicationContext applicationContext); void validateContextToUri(ContainerRequest request, SLIPrincipal principal); boolean isUrlBlocked(ContainerRequest request); List<PathSegment> cleanEmptySegments(List<PathSegment> pathSegments); void validateContextToCallUri(List<PathSegment> segments); boolean checkAccessOfStudentsThroughDisciplineIncidents(List<PathSegment> segments); void validateContextToEntities(EntityDefinition def, Collection<String> ids, boolean isTransitive); Set<String> getValidIdsIncludeOrphans(EntityDefinition def, Set<String> ids, boolean isTransitive); Map<String, SecurityUtil.UserContext> getValidatedEntityContexts(EntityDefinition def, Collection<Entity> entities, boolean isTransitive, boolean isRead); IContextValidator findValidator(String toType, boolean isTransitive); static boolean isTransitive(List<PathSegment> segs); List<IContextValidator> findContextualValidators(String toType, boolean isTransitive); boolean isGlobalEntity(String type); }### Answer: @Test public void testgetEntityIdsToValidateForgiving() { Entity student0 = createEntity("student", 0); Entity student1 = createEntity("student", 1); Entity student2 = createEntity("student", 2); List<Entity> students = Arrays.asList(student0, student1, student2); boolean isTransitive = false; Mockito.when(ownership.canAccess(student0, isTransitive)).thenReturn(true); Mockito.when(ownership.canAccess(student1, isTransitive)).thenReturn(true); Mockito.when(ownership.canAccess(student2, isTransitive)).thenThrow(new AccessDeniedException("")); Set<String> ids = contextValidator.getEntityIdsToValidateForgiving(students, isTransitive); Assert.assertEquals(2, ids.size()); Assert.assertTrue(ids.contains(student0.getEntityId())); Assert.assertTrue(ids.contains(student1.getEntityId())); }
### Question: MongoCommander { public static String preSplit(Set<String> shardCollections, String dbName, MongoTemplate mongoTemplate) { DB dbConn = mongoTemplate.getDb().getSisterDB("admin"); List<String> shards = getShards(dbConn); if (shards.size() == 0) { return null; } String sresult = setBalancerState(dbConn, false); if (sresult != null) { return sresult; } DBObject enableShard = new BasicDBObject("enableSharding", dbName); CommandResult result = dbConn.command(enableShard); if (!result.ok()) { LOG.error("Error enabling sharding on {}: {}", dbConn, result.getErrorMessage()); return result.getErrorMessage(); } for (String coll : shardCollections) { String collection = dbName + "." + coll; DBObject shardColl = new BasicDBObject(); shardColl.put("shardCollection", collection); shardColl.put("key", new BasicDBObject(ID, 1)); result = dbConn.command(shardColl); if (!result.ok()) { LOG.error("Error enabling shard'ing on {}: {}", collection, result.getErrorMessage()); return result.getErrorMessage(); } sresult = moveChunks(collection, shards, dbConn); if (sresult != null) { return sresult; } } return preSplitBinCollections(dbName, mongoTemplate); } private MongoCommander(); static String ensureIndexes(String indexFile, String db, MongoTemplate mongoTemplate); static String ensureIndexes(Set<String> indexes, String db, MongoTemplate mongoTemplate); static String ensureIndexes(Set<MongoIndex> indexes, DB dbConn); @SuppressWarnings("boxing") static String ensureIndexes(MongoIndex index, DB dbConn, int indexOrder); static String preSplit(Set<String> shardCollections, String dbName, MongoTemplate mongoTemplate); static DB getDB(String db, MongoTemplate mongoTemplate); static DB getDB(String db, DB dbConn); static final String STR_0X38; }### Answer: @Test public void testPreSplit() { List<DBObject> shards = new ArrayList<DBObject>(); shards.add(new BasicDBObject("_id", "shard0")); shards.add(new BasicDBObject("_id", "shard1")); BasicDBList listShards = new BasicDBList(); listShards.add(new BasicDBObject("shards", shards)); List<String> lShards = new ArrayList<String>(); lShards.add("shard0"); lShards.add("lShard1"); Mockito.when(db.command((DBObject) Matchers.any())).thenReturn(res); Mockito.when(res.get("shards")).thenReturn(listShards); String result = MongoCommander.preSplit(shardCollections, dbName, mockedMongoTemplate); assertNull(result); Mockito.verify(db, Mockito.times(1)).command(new BasicDBObject("enableSharding", dbName)); Mockito.verify(db, Mockito.times(2)).command(new BasicDBObject("listShards", 1)); Mockito.verify(db, Mockito.times(13)).command(Matchers.any(DBObject.class)); Mockito.verify(settings, Mockito.times(1)).update(Matchers.any(DBObject.class), Matchers.any(DBObject.class), Matchers.eq(true), Matchers.eq(false)); }
### Question: EdOrgHelper { public Set<Entity> locateNonExpiredSEOAs(String staffId) { Set<Entity> validAssociations = new HashSet<Entity>(); NeutralQuery basicQuery = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_REFERENCE, NeutralCriteria.OPERATOR_EQUAL, staffId)); Iterable<Entity> associations = repo.findAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, basicQuery); for (Entity association : associations) { if (!dateHelper.isFieldExpired(association.getBody(), ParameterConstants.END_DATE, false)) { validAssociations.add(association); } } return validAssociations; } @PostConstruct void init(); List<String> getDistricts(Entity user); List<String> getDistricts(Set<String> edOrgs); List<String> getDirectChildLEAsOfEdOrg(Entity edOrgEntity); Set<String> getAllChildLEAsOfEdOrg(Entity edOrgEntity); List<String> getParentEdOrgs(Entity edOrgEntity); Entity byId(String edOrgId); boolean isSEA(Entity entity); String getSEAOfEdOrg(Entity entity); List<String> getDirectSchools(Entity principal); List<String> getDirectSchoolsLineage(Entity principal, boolean getLineage); Set<String> getChildEdOrgs(Collection<String> edOrgs); Set<String> getChildEdOrgs(String edOrg); Set<String> getChildEdOrgs(final Set<String> visitedEdOrgs, Collection<String> edOrgs); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds, boolean includeParents); Collection<String> getUserEdOrgs(Entity principal); Set<String> getStaffEdOrgsAndChildren(); Set<String> getEdorgDescendents(Set<String> edOrgLineage); Set<String> getDelegatedEdorgDescendents(); boolean isFieldExpired(Map<String, Object> body, String fieldName, boolean useGracePeriod); @SuppressWarnings("unchecked") boolean isLEA(Entity entity); @SuppressWarnings("unchecked") boolean isSchool(Entity entity); Set<String> getDirectEdorgs(); Set<String> getDirectEdorgs(Entity principal); List<String> getUserEdorgs(Entity principal); Set<String> locateDirectEdorgs(Entity principal); Set<Entity> locateValidSEOAs(String staffId, boolean filterByOwnership); Set<Entity> locateNonExpiredSEOAs(String staffId); Set<String> getEdOrgStateOrganizationIds(Set<String> edOrgIds); }### Answer: @Test public void testTeacher3LocateSEOAs() { NeutralQuery staffQuery = new NeutralQuery(); staffQuery.addCriteria(new NeutralCriteria(ParameterConstants.STAFF_UNIQUE_STATE_ID, NeutralCriteria.OPERATOR_EQUAL, teacher3.getEntityId())); repo.deleteAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, staffQuery); Date now = new Date(); setupSEOAs(repo, now.getTime(), teacher3, school3.getEntityId()); Set<Entity> associations = helper.locateNonExpiredSEOAs(teacher3.getEntityId()); assertTrue("teacher3 should have 3 valid associations", associations.size() == 3); }
### Question: IndexJSFileParser implements IndexParser<String> { @Override public Set<MongoIndex> parse(String fileName) { Map<String, Object> indexMap = null; File resourceFile = null; FileInputStream fstream = null; BufferedReader br = null; Set<MongoIndex> indexes = new HashSet<MongoIndex>(); try { URL resourceURL = Thread.currentThread().getContextClassLoader().getResource(fileName); if (resourceURL != null) { resourceFile = new File(resourceURL.toURI()); if (resourceFile != null) { fstream = new FileInputStream(resourceFile); br = new BufferedReader(new InputStreamReader(fstream)); String collectionName = null; String keyJsonString; String currentFileLine; while ((currentFileLine = br.readLine()) != null) { boolean unique = false; Matcher indexMatcher = ensureIndexStatement(currentFileLine); if (indexMatcher != null) { collectionName = indexMatcher.group(1); keyJsonString = indexMatcher.group(2); if (indexMatcher.group(3) != null) { unique = Boolean.parseBoolean(indexMatcher.group(4)); } indexMap = parseJson(keyJsonString); DBObject keyObj = new BasicDBObject(indexMap); indexes.add(new MongoIndex(collectionName, unique, keyObj)); } } } } } catch (IOException e) { LOG.error("Error reading index file:" + e.getMessage()); } catch (URISyntaxException e) { LOG.error("Index file not found: " + e.getMessage()); } finally { IOUtils.closeQuietly(br); IOUtils.closeQuietly(fstream); } return indexes; } @Override Set<MongoIndex> parse(String fileName); static Map<String, Object> parseJson(String jsonString); }### Answer: @Test public void parseJSTest() { IndexJSFileParser indexJSFileParser = new IndexJSFileParser(); Set<MongoIndex> indexes = indexJSFileParser.parse(INDEX_FILE); Map<String, MongoIndex> expectedIndexes = new HashMap<String, MongoIndex>(); DBObject userSessionIndex = new BasicDBObject(); userSessionIndex.put("body.expiration", 1); userSessionIndex.put("body.hardLogout", 1); userSessionIndex.put("body.appSession.token", 1); expectedIndexes.put("usersession", new MongoIndex("userSession", false, userSessionIndex)); DBObject tenantIndex = new BasicDBObject(); tenantIndex.put("body.tenantId", 1); expectedIndexes.put("tenant", new MongoIndex("tenant", true, tenantIndex)); assertEquals(4, indexes.size()); for (MongoIndex idx : indexes) { if (idx.getCollection().equalsIgnoreCase("realm")) { fail("Invalid index was parsed"); } else if (idx.getCollection().equalsIgnoreCase("usersession")) { assertEquals(idx, expectedIndexes.get("usersession")); } else if (idx.getCollection().equalsIgnoreCase("tenant")) { assertEquals(idx, expectedIndexes.get("tenant")); assertTrue(idx.isUnique()); } } }
### Question: EdOrgHelper { public Set<String> getDirectEdorgs() { LOG.trace(">>>EdOrgHelper.getDirectEdorgs()"); return getDirectEdorgs(SecurityUtil.getSLIPrincipal().getEntity()); } @PostConstruct void init(); List<String> getDistricts(Entity user); List<String> getDistricts(Set<String> edOrgs); List<String> getDirectChildLEAsOfEdOrg(Entity edOrgEntity); Set<String> getAllChildLEAsOfEdOrg(Entity edOrgEntity); List<String> getParentEdOrgs(Entity edOrgEntity); Entity byId(String edOrgId); boolean isSEA(Entity entity); String getSEAOfEdOrg(Entity entity); List<String> getDirectSchools(Entity principal); List<String> getDirectSchoolsLineage(Entity principal, boolean getLineage); Set<String> getChildEdOrgs(Collection<String> edOrgs); Set<String> getChildEdOrgs(String edOrg); Set<String> getChildEdOrgs(final Set<String> visitedEdOrgs, Collection<String> edOrgs); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds, boolean includeParents); Collection<String> getUserEdOrgs(Entity principal); Set<String> getStaffEdOrgsAndChildren(); Set<String> getEdorgDescendents(Set<String> edOrgLineage); Set<String> getDelegatedEdorgDescendents(); boolean isFieldExpired(Map<String, Object> body, String fieldName, boolean useGracePeriod); @SuppressWarnings("unchecked") boolean isLEA(Entity entity); @SuppressWarnings("unchecked") boolean isSchool(Entity entity); Set<String> getDirectEdorgs(); Set<String> getDirectEdorgs(Entity principal); List<String> getUserEdorgs(Entity principal); Set<String> locateDirectEdorgs(Entity principal); Set<Entity> locateValidSEOAs(String staffId, boolean filterByOwnership); Set<Entity> locateNonExpiredSEOAs(String staffId); Set<String> getEdOrgStateOrganizationIds(Set<String> edOrgIds); }### Answer: @Test public void testStudent1() { Set<String> edorgs = helper.getDirectEdorgs(student1); assertEquals(1, edorgs.size()); assertTrue("student1 should see school1", edorgs.contains(school1.getEntityId())); assertFalse("student1 should not see school2", edorgs.contains(school2.getEntityId())); assertFalse("student1 should not see school3", edorgs.contains(school3.getEntityId())); } @Test public void testStudent2() { Set<String> edorgs = helper.getDirectEdorgs(student2); assertEquals(1, edorgs.size()); assertFalse("student2 should not see school1", edorgs.contains(school1.getEntityId())); assertTrue("student2 should see school2", edorgs.contains(school2.getEntityId())); assertFalse("student2 should not see school3", edorgs.contains(school3.getEntityId())); } @Test public void testStudent3() { Set<String> edorgs = helper.getDirectEdorgs(student3); assertEquals(1, edorgs.size()); assertFalse("student3 should not see school1", edorgs.contains(school1.getEntityId())); assertFalse("student3 should not see school2", edorgs.contains(school2.getEntityId())); assertTrue("student3 should see school3", edorgs.contains(school3.getEntityId())); }
### Question: EdOrgHelper { public List<String> getDirectChildLEAsOfEdOrg(Entity edOrgEntity) { Set<String> result; if (edOrgEntity == null) { return null; } result = getDirectChildLEAsOfEdOrg(edOrgEntity.getEntityId()); if (result == null \|\| result.isEmpty()) { return null; } return new ArrayList<String>(result); } @PostConstruct void init(); List<String> getDistricts(Entity user); List<String> getDistricts(Set<String> edOrgs); List<String> getDirectChildLEAsOfEdOrg(Entity edOrgEntity); Set<String> getAllChildLEAsOfEdOrg(Entity edOrgEntity); List<String> getParentEdOrgs(Entity edOrgEntity); Entity byId(String edOrgId); boolean isSEA(Entity entity); String getSEAOfEdOrg(Entity entity); List<String> getDirectSchools(Entity principal); List<String> getDirectSchoolsLineage(Entity principal, boolean getLineage); Set<String> getChildEdOrgs(Collection<String> edOrgs); Set<String> getChildEdOrgs(String edOrg); Set<String> getChildEdOrgs(final Set<String> visitedEdOrgs, Collection<String> edOrgs); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds, boolean includeParents); Collection<String> getUserEdOrgs(Entity principal); Set<String> getStaffEdOrgsAndChildren(); Set<String> getEdorgDescendents(Set<String> edOrgLineage); Set<String> getDelegatedEdorgDescendents(); boolean isFieldExpired(Map<String, Object> body, String fieldName, boolean useGracePeriod); @SuppressWarnings("unchecked") boolean isLEA(Entity entity); @SuppressWarnings("unchecked") boolean isSchool(Entity entity); Set<String> getDirectEdorgs(); Set<String> getDirectEdorgs(Entity principal); List<String> getUserEdorgs(Entity principal); Set<String> locateDirectEdorgs(Entity principal); Set<Entity> locateValidSEOAs(String staffId, boolean filterByOwnership); Set<Entity> locateNonExpiredSEOAs(String staffId); Set<String> getEdOrgStateOrganizationIds(Set<String> edOrgIds); }### Answer: @Test public void testGetChildLeaOfEdorgs() { List<String> edorgs = helper.getDirectChildLEAsOfEdOrg(lea2); assertEquals(1, edorgs.size()); assertFalse("lea1 should not be a child of lea2", edorgs.contains(lea1.getEntityId())); assertFalse("lea2 should not be a child of lea2", edorgs.contains(lea2.getEntityId())); assertTrue("lea3 should be a child of lea2", edorgs.contains(lea3.getEntityId())); }
### Question: EdOrgHelper { public Set<String> getAllChildLEAsOfEdOrg(Entity edOrgEntity) { String myId; Set<String> edOrgs = new HashSet<String>(); Set<String> result = new HashSet<String>(); if (edOrgEntity == null \|\| edOrgEntity.getEntityId() == null) { return null; } myId = edOrgEntity.getEntityId(); edOrgs.add(myId); result = getAllChildLEAsOfEdOrg(edOrgs, new HashSet<String>()); result.remove(myId); return result; } @PostConstruct void init(); List<String> getDistricts(Entity user); List<String> getDistricts(Set<String> edOrgs); List<String> getDirectChildLEAsOfEdOrg(Entity edOrgEntity); Set<String> getAllChildLEAsOfEdOrg(Entity edOrgEntity); List<String> getParentEdOrgs(Entity edOrgEntity); Entity byId(String edOrgId); boolean isSEA(Entity entity); String getSEAOfEdOrg(Entity entity); List<String> getDirectSchools(Entity principal); List<String> getDirectSchoolsLineage(Entity principal, boolean getLineage); Set<String> getChildEdOrgs(Collection<String> edOrgs); Set<String> getChildEdOrgs(String edOrg); Set<String> getChildEdOrgs(final Set<String> visitedEdOrgs, Collection<String> edOrgs); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds); Set<String> getChildEdOrgsName(Collection<String> parentEdOrgIds, boolean includeParents); Collection<String> getUserEdOrgs(Entity principal); Set<String> getStaffEdOrgsAndChildren(); Set<String> getEdorgDescendents(Set<String> edOrgLineage); Set<String> getDelegatedEdorgDescendents(); boolean isFieldExpired(Map<String, Object> body, String fieldName, boolean useGracePeriod); @SuppressWarnings("unchecked") boolean isLEA(Entity entity); @SuppressWarnings("unchecked") boolean isSchool(Entity entity); Set<String> getDirectEdorgs(); Set<String> getDirectEdorgs(Entity principal); List<String> getUserEdorgs(Entity principal); Set<String> locateDirectEdorgs(Entity principal); Set<Entity> locateValidSEOAs(String staffId, boolean filterByOwnership); Set<Entity> locateNonExpiredSEOAs(String staffId); Set<String> getEdOrgStateOrganizationIds(Set<String> edOrgIds); }### Answer: @Test public void testGetAllChildLeaOfEdorgs() { Set<String> edorgs = helper.getAllChildLEAsOfEdOrg(sea1); assertEquals(4, edorgs.size()); assertTrue("lea1 should be a child of sea1", edorgs.contains(lea1.getEntityId())); assertTrue("lea2 should be a child of sea1", edorgs.contains(lea2.getEntityId())); assertTrue("lea3 should be a child of sea1", edorgs.contains(lea3.getEntityId())); assertTrue("lea4 should be a child of sea1", edorgs.contains(lea4.getEntityId())); } @Test public void testGetAllChildLeaOfEdorgsWithCycle() { Set<String> edorgs = helper.getAllChildLEAsOfEdOrg(leaCycle1); assertEquals(2, edorgs.size()); assertFalse("leaCycle1 should not be a child of leaCycle1", edorgs.contains(leaCycle1.getEntityId())); assertTrue("leaCycle2 should be a child of leaCycle1", edorgs.contains(leaCycle2.getEntityId())); assertTrue("leaCycle3 should be a child of leaCycle1", edorgs.contains(leaCycle3.getEntityId())); }
### Question: IndexTxtFileParser implements IndexParser<String> { @Override public Set<MongoIndex> parse(String fileName) { Set<String> indexSet = loadIndexes(fileName); return new IndexSliFormatParser().parse(indexSet); } @Override Set<MongoIndex> parse(String fileName); static Set<String> loadIndexes(String indexFile); }### Answer: @Test public void parseTxtTest() { IndexTxtFileParser indexTxtFileParser = new IndexTxtFileParser(); Set<MongoIndex> indexes = indexTxtFileParser.parse(INDEX_TXT_FILE); assertEquals(2, indexes.size()); Map<String, MongoIndex> expectedIndex = new HashMap<String, MongoIndex>(); DBObject adminDelegationIndex = new BasicDBObject(); adminDelegationIndex.put("body.localEdOrgId", 1); expectedIndex.put("adminDelegation", new MongoIndex("adminDelegation", false, adminDelegationIndex, false)); DBObject applicationAuthorizationIndex = new BasicDBObject(); applicationAuthorizationIndex.put("body.appIds", 1); expectedIndex.put("applicationAuthorization", new MongoIndex("applicationAuthorization", true, applicationAuthorizationIndex, false)); for (MongoIndex index : indexes) { String collection = index.getCollection(); if (collection.equalsIgnoreCase("learningObjective")) { fail("Invalid index was parsed"); } else if (collection.equalsIgnoreCase("adminDelegation")) { assertEquals(index, expectedIndex.get("adminDelegation")); } else if (collection.equalsIgnoreCase("applicationAuthorization")) { assertEquals(index, expectedIndex.get("applicationAuthorization")); assertTrue(index.isUnique()); } } }
### Question: RealmHelper { public Set<String> getAssociatedRealmIds() { HashSet<String> toReturn = new HashSet<String>(); if (isSandboxEnabled) { toReturn.add(getSandboxRealmId()); } else { NeutralQuery realmQuery = new NeutralQuery(); String edOrg = SecurityUtil.getEdOrg(); LOG.debug("Looking up realms for edorg {}.", edOrg); realmQuery.addCriteria(new NeutralCriteria("edOrg", NeutralCriteria.OPERATOR_EQUAL, edOrg)); realmQuery .addCriteria(new NeutralCriteria("tenantId", NeutralCriteria.OPERATOR_EQUAL, SecurityUtil .getTenantId())); Iterable<String> realmIds = repo.findAllIds("realm", realmQuery); for (String id : realmIds) { toReturn.add(id); } } return toReturn; } String getSandboxRealmId(); String getAdminRealmId(); String getEdOrgIdFromRealm(String realmId); Entity getRealmFromSession(String sessionId); List<String> getPreferredLoginRealmIds(Entity userEntity); Iterable<Entity> getRealms(Entity edOrg); boolean isUserAllowedLoginToRealm(Entity userEntity, Entity realm); Set<String> getAssociatedRealmIds(); Entity findRealmById(String id); static final String USER_SESSION; }### Answer: @Test public void testGetAssociatedRealmIsTenantSpecific() { Entity sea = buildEdOrg("SEA1", null, injector.TENANT_ID, true); Entity lea1 = buildEdOrg("LEA1", sea, injector.TENANT_ID, false); Entity lea2 = buildEdOrg("LEA1", null, "Two", false); Entity lea2Realm = buildRealm(lea2, "Two"); Entity lea1Realm = buildRealm(lea1, injector.TENANT_ID); Entity staff = buildStaff("LEA One", lea1); injector.setCustomContext("LEA", "LEA One", lea1Realm.getEntityId(), Arrays.asList("Realm Administrator"), staff, (String) lea1Realm.getBody().get("edOrg")); Set<String> realmIds = helper.getAssociatedRealmIds(); assertTrue(realmIds != null); assertTrue(realmIds.contains(lea1Realm.getEntityId())); }
### Question: PurgeProcessor implements Processor { @Override public void process(Exchange exchange) throws Exception { Stage stage = Stage.createAndStartStage(BATCH_JOB_STAGE, BATCH_JOB_STAGE_DESC); String batchJobId = getBatchJobId(exchange); if (batchJobId != null) { reportStats = new SimpleReportStats(); NewBatchJob newJob = null; try { newJob = batchJobDAO.findBatchJobById(batchJobId); TenantContext.setTenantId(newJob.getTenantId()); String tenantId = newJob.getTenantId(); if (tenantId == null) { handleNoTenantId(batchJobId); } else { purgeForTenant(exchange, newJob, tenantId); } } catch (Exception exception) { handleProcessingExceptions(exchange, batchJobId, exception); } finally { if (newJob != null) { BatchJobUtils.stopStageAndAddToJob(stage, newJob); batchJobDAO.saveBatchJob(newJob); } } } else { missingBatchJobIdError(exchange); } } @Override void process(Exchange exchange); MongoTemplate getMongoTemplate(); void setMongoTemplate(MongoTemplate mongoTemplate); BatchJobDAO getBatchJobDAO(); AbstractMessageReport getMessageReport(); boolean isSandboxEnabled(); void setBatchJobDAO(BatchJobDAO batchJobDAO); void setMessageReport(AbstractMessageReport messageReport); void setSandboxEnabled(boolean sandboxEnabled); void setPurgeBatchSize(int purgeBatchSize); void setDeltaJournal(DeltaJournal deltaJournal); void setDeltasEnabled(boolean deltasEnabled); static final BatchJobStageType BATCH_JOB_STAGE; }### Answer: @Test public void testPurgingSystemCollections() throws Exception { RangedWorkNote workNote = RangedWorkNote.createSimpleWorkNote(BATCHJOBID); Exchange ex = Mockito.mock(Exchange.class); Message message = Mockito.mock(Message.class); Mockito.when(ex.getIn()).thenReturn(message); Mockito.when(message.getBody(RangedWorkNote.class)).thenReturn(workNote); NewBatchJob job = new NewBatchJob(); job.setProperty("tenantId", "SLI"); Mockito.when(mockBatchJobDAO.findBatchJobById(BATCHJOBID)).thenReturn(job); Set<String> collectionNames = new HashSet<String>(); collectionNames.add("system.js"); collectionNames.add("system.indexes"); Mockito.when(mongoTemplate.getCollectionNames()).thenReturn(collectionNames); purgeProcessor.process(ex); Mockito.verify(mongoTemplate, Mockito.never()).remove(Mockito.any(Query.class), Mockito.eq("system.js")); }
### Question: ZipFileProcessor implements Processor { @Override public void process(Exchange exchange) throws Exception { WorkNote workNote = exchange.getIn().getBody(WorkNote.class); String batchJobId = workNote.getBatchJobId(); if (batchJobId == null) { handleNoBatchJobIdInExchange(exchange); } else { processZipFile(exchange, batchJobId); } } @Override void process(Exchange exchange); ZipFileHandler getHandler(); void setHandler(ZipFileHandler handler); static final BatchJobStageType BATCH_JOB_STAGE; }### Answer: @Test public void testHappyZipFileProcessor() throws Exception { Exchange preObject = new DefaultExchange(new DefaultCamelContext()); String batchJobId = NewBatchJob.createId("ValidZip.zip"); Mockito.when(workNote.getBatchJobId()).thenReturn(batchJobId); preObject.getIn().setBody(workNote); Mockito.when(mockedBatchJobDAO.findBatchJobById(Matchers.eq(batchJobId))).thenReturn(mockedJob); File zipFile = IngestionTest.getFile("zip/ValidZip.zip"); ResourceEntry entry = new ResourceEntry(); entry.setResourceName(zipFile.getAbsolutePath()); Mockito.when(mockedJob.getZipResourceEntry()).thenReturn(entry); createResourceEntryAndAddToJob(zipFile, mockedJob); mockedJob.setSourceId("zip"); preObject.getIn().setHeader("BatchJobId", batchJobId); zipProc.process(preObject); Assert.assertNotNull(preObject.getIn().getBody()); } @Test public void testNoControlFileZipFileProcessor() throws Exception { Exchange preObject = new DefaultExchange(new DefaultCamelContext()); String batchJobId = NewBatchJob.createId("NoControlFile.zip"); Mockito.when(workNote.getBatchJobId()).thenReturn(batchJobId); preObject.getIn().setBody(workNote); Mockito.when(mockedBatchJobDAO.findBatchJobById(Matchers.eq(batchJobId))).thenReturn(mockedJob); File zipFile = IngestionTest.getFile("zip/NoControlFile.zip"); ResourceEntry entry = new ResourceEntry(); entry.setResourceName(zipFile.getAbsolutePath()); Mockito.when(mockedJob.getZipResourceEntry()).thenReturn(entry); createResourceEntryAndAddToJob(zipFile, mockedJob); mockedJob.setSourceId("zip"); Mockito.when(mockedBatchJobDAO.findBatchJobById(Matchers.eq(batchJobId))).thenReturn(mockedJob); preObject.getIn().setHeader("BatchJobId", batchJobId); zipProc.process(preObject); Assert.assertNotNull(preObject.getIn().getBody()); Assert.assertTrue(preObject.getIn().getBody(WorkNote.class).hasErrors()); Assert.assertEquals(preObject.getIn().getHeader("IngestionMessageType") , MessageType.BATCH_REQUEST.name()); }
### Question: EdOrgOwnershipArbiter extends OwnershipArbiter { public Set<String> determineHierarchicalEdorgs(Iterable<Entity> entities, String entityType) { Set<String> hierarchicalEdorgs = new HashSet<String>(); List<Entity> edorgs = findOwner(entities, entityType, true); for (Entity edorg : edorgs) { hierarchicalEdorgs.add(edorg.getEntityId()); hierarchicalEdorgs.addAll(helper.getParentEdOrgs(edorg)); } return hierarchicalEdorgs; } @SuppressWarnings("unused") @PostConstruct void init(); Set<String> determineEdorgs(Iterable<Entity> entities, String entityType); Set<String> determineHierarchicalEdorgs(Iterable<Entity> entities, String entityType); boolean isEntityOwnedByEdOrg(String entityType); }### Answer: @Test public void testHierarchicalEdOrgs() { securityContextInjector.setStaffContext(); Entity edorg1 = createEntity(EntityNames.SCHOOL, "edorg1", new HashMap<String, Object>()); Mockito.when(repo.findAll(Mockito.eq(EntityNames.EDUCATION_ORGANIZATION), Mockito.any(NeutralQuery.class))).thenReturn( Arrays.asList(edorg1)); Mockito.when(helper.getParentEdOrgs(edorg1)).thenReturn(Arrays.asList("edorg1Parent1", "edorg1Parent2")); Map<String, Object> attendanceBody = new HashMap<String, Object>(); attendanceBody.put(ParameterConstants.SCHOOL_ID, "edorg1"); Entity attendance = createEntity(EntityNames.ATTENDANCE, "attendance1", attendanceBody); Set<String> edorgIds = arbiter.determineHierarchicalEdorgs(Arrays.asList(attendance), EntityNames.ATTENDANCE); Assert.assertEquals(3, edorgIds.size()); Assert.assertTrue(edorgIds.contains("edorg1")); Assert.assertTrue(edorgIds.contains("edorg1Parent1")); Assert.assertTrue(edorgIds.contains("edorg1Parent2")); } @Test public void testOrphanedEntity() { securityContextInjector.setStaffContext(); Entity principalEntity = Mockito.mock(Entity.class); Mockito.when(principalEntity.getEntityId()).thenReturn("doofus1_id"); SLIPrincipal principal = Mockito.mock(SLIPrincipal.class); Mockito.when(principal.getEntity()).thenReturn(principalEntity); securityContextInjector.setOauthSecurityContext(principal, false); Mockito.when(repo.findAll(Mockito.anyString(), Mockito.any(NeutralQuery.class))).thenReturn(new ArrayList<Entity>()); Map<String, Object> metaData = new HashMap<String, Object>(); metaData.put("createdBy", "doofus1_id"); metaData.put("isOrphaned", "true"); Entity student1 = new MongoEntity(EntityNames.STUDENT, "student1", new HashMap<String, Object>(), metaData); Set<String> edorgIds = arbiter.determineHierarchicalEdorgs(Arrays.asList(student1), EntityNames.STUDENT); Assert.assertTrue(edorgIds.isEmpty()); }
### Question: ParentAccessValidator extends AccessValidator { @Override protected boolean isReadAllowed(List<String> path, MultivaluedMap<String, String> queryParameters) { List<String> subPath = null; if (path.size() == 3) { subPath = Arrays.asList(path.get(2)); } else if (path.size() == 4) { subPath = Arrays.asList(path.get(2), path.get(3)); } if (subPath != null && path.get(0).equals(ResourceNames.PARENTS) && ALLOWED_DELTA_FOR_PARENT.contains(subPath)) { return true; } return studentAccessValidator.isReadAllowed(path, queryParameters); } }### Answer: @Test public void followStudents() { paths = Arrays.asList("v1", ResourceNames.STUDENT_SCHOOL_ASSOCIATIONS, "ssa123", ResourceNames.STUDENTS); when(studentValidator.isReadAllowed(Matchers.anyListOf(String.class), any(MultivaluedMapImpl.class))).thenReturn(true); assertTrue(underTest.isAllowed(request)); paths = Arrays.asList("v1", ResourceNames.TEACHERS, "teacher123", ResourceNames.TEACHER_SECTION_ASSOCIATIONS); when(studentValidator.isReadAllowed(Matchers.anyListOf(String.class), any(MultivaluedMapImpl.class))).thenReturn(false); assertFalse(underTest.isAllowed(request)); }
### Question: DeltaHashPurgeProcessor extends IngestionProcessor<WorkNote, Resource> { @Override public void process(Exchange exchange, ProcessorArgs<WorkNote> args) { String tenantId = TenantContext.getTenantId(); removeRecordHash(args.job, tenantId); } @Override void process(Exchange exchange, ProcessorArgs<WorkNote> args); static final BatchJobStageType BATCH_JOB_STAGE; }### Answer: @Test public void testPurgeDeltas() throws Exception { Mockito.when(job.getProperty(AttributeType.DUPLICATE_DETECTION.getName())).thenReturn(RecordHash.RECORD_HASH_MODE_DISABLE); Exchange exchange = new DefaultExchange(new DefaultCamelContext()); WorkNote workNote = new WorkNote("batchJobId", false); exchange.getIn().setBody(workNote); deltaHashPurgeProcessor.process(exchange); Mockito.verify(batchJobDAO, Mockito.atLeastOnce()).removeRecordHashByTenant("tenantId"); }
### Question: TeacherToTeacherSectionAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.TEACHER_SECTION_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery nq = new NeutralQuery(new NeutralCriteria(ParameterConstants.TEACHER_ID, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil.getSLIPrincipal().getEntity().getEntityId())); nq.addCriteria(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); Iterable<String> tsaIds = getRepo().findAllIds(EntityNames.TEACHER_SECTION_ASSOCIATION, nq); return Sets.newHashSet(tsaIds); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testValidateWrongType() { val.validate(EntityNames.ASSESSMENT, new HashSet<String>(Arrays.asList("Jomolungma"))); } @Test public void testSuccessOne() { Entity tsa = this.vth.generateTSA(USER_ID, SECTION_ID, false); Set<String> ids = Collections.singleton(tsa.getEntityId()); Assert.assertTrue(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testSuccessMulti() { Set<String> ids = new HashSet<String>(); for (int i = 0; i < 100; i++) { ids.add(this.vth.generateTSA(USER_ID, SECTION_ID, false).getEntityId()); } Assert.assertTrue(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testWrongId() { Set<String> ids = Collections.singleton("Hammerhands"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); ids = Collections.singleton("Nagas"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE,ids).equals(ids)); ids = Collections.singleton("Phantom Warriors"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testHeterogenousList() { Set<String> ids = new HashSet<String>(Arrays .asList(this.vth.generateTSA(USER_ID, SECTION_ID, false).getEntityId(), this.vth.generateTSA("Ssss'ra", "Arcanus", false).getEntityId(), this.vth.generateTSA("Kali", "Arcanus", false).getEntityId())); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); }
### Question: GlobalEntityValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTransitive && isGlobalWrite(entityType) && !isStudentOrParent(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> entityIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidationStaff() throws Exception { assertTrue(validator.canValidate(EntityNames.ASSESSMENT, true)); assertFalse(validator.canValidate(EntityNames.ASSESSMENT, false)); assertTrue(validator.canValidate(EntityNames.LEARNING_OBJECTIVE, true)); assertFalse(validator.canValidate(EntityNames.LEARNING_OBJECTIVE, false)); assertTrue(validator.canValidate(EntityNames.LEARNING_STANDARD, true)); assertFalse(validator.canValidate(EntityNames.LEARNING_STANDARD, false)); assertTrue(validator.canValidate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, true)); assertFalse(validator.canValidate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); } @Test public void testCanValidationTeacher() throws Exception { injector.setEducatorContext(); assertTrue(validator.canValidate(EntityNames.ASSESSMENT, true)); assertFalse(validator.canValidate(EntityNames.ASSESSMENT, false)); assertTrue(validator.canValidate(EntityNames.LEARNING_OBJECTIVE, true)); assertFalse(validator.canValidate(EntityNames.LEARNING_OBJECTIVE, false)); assertTrue(validator.canValidate(EntityNames.LEARNING_STANDARD, true)); assertFalse(validator.canValidate(EntityNames.LEARNING_STANDARD, false)); assertTrue(validator.canValidate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, true)); assertFalse(validator.canValidate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, false)); assertFalse(validator.canValidate(EntityNames.COHORT, true)); }
### Question: GlobalEntityValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> entityIds) throws IllegalStateException { Set<String> result = new HashSet<String>(); if(areParametersValid(GLOBAL_WRITE_RESOURCE, entityType, entityIds)) { result = entityIds; } return result; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> entityIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidateSingleAssessment() throws Exception { HashSet<String> assessmentIds = new HashSet<String>(); assessmentIds.add(helper.generateAssessment().getEntityId()); assertTrue(validator.validate(EntityNames.ASSESSMENT, assessmentIds).containsAll(assessmentIds)); } @Test public void testValidateMultipleAssessments() throws Exception { HashSet<String> assessmentIds = new HashSet<String>(); assessmentIds.add(helper.generateAssessment().getEntityId()); assessmentIds.add(helper.generateAssessment().getEntityId()); assessmentIds.add(helper.generateAssessment().getEntityId()); assertTrue(validator.validate(EntityNames.ASSESSMENT, assessmentIds).containsAll(assessmentIds)); } @Test public void testValidateSingleLearningObjective() throws Exception { HashSet<String> learningObjectiveIds = new HashSet<String>(); learningObjectiveIds.add(helper.generateLearningObjective().getEntityId()); assertTrue(validator.validate(EntityNames.LEARNING_OBJECTIVE, learningObjectiveIds).containsAll(learningObjectiveIds)); } @Test public void testValidateMultipleLearningObjectives() throws Exception { HashSet<String> learningObjectiveIds = new HashSet<String>(); learningObjectiveIds.add(helper.generateLearningObjective().getEntityId()); learningObjectiveIds.add(helper.generateLearningObjective().getEntityId()); learningObjectiveIds.add(helper.generateLearningObjective().getEntityId()); assertTrue(validator.validate(EntityNames.LEARNING_OBJECTIVE, learningObjectiveIds).containsAll(learningObjectiveIds)); } @Test public void testValidateSingleLearningStandard() throws Exception { HashSet<String> learningStandardIds = new HashSet<String>(); learningStandardIds.add(helper.generateLearningStandard().getEntityId()); assertTrue(validator.validate(EntityNames.LEARNING_STANDARD, learningStandardIds).containsAll(learningStandardIds)); } @Test public void testValidateMultipleLearningStandards() throws Exception { HashSet<String> learningStandardIds = new HashSet<String>(); learningStandardIds.add(helper.generateLearningStandard().getEntityId()); learningStandardIds.add(helper.generateLearningStandard().getEntityId()); learningStandardIds.add(helper.generateLearningStandard().getEntityId()); assertTrue(validator.validate(EntityNames.LEARNING_STANDARD, learningStandardIds).containsAll(learningStandardIds)); } @Test public void testValidateSingleCompetencyLevelDescriptor() throws Exception { HashSet<String> competencyLevelDescriptorIds = new HashSet<String>(); competencyLevelDescriptorIds.add(helper.generateCompetencyLevelDescriptor().getEntityId()); assertTrue(validator.validate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, competencyLevelDescriptorIds).containsAll(competencyLevelDescriptorIds)); } @Test public void testValidateMultipleCompetencyLevelDescriptors() throws Exception { HashSet<String> competencyLevelDescriptorIds = new HashSet<String>(); competencyLevelDescriptorIds.add(helper.generateCompetencyLevelDescriptor().getEntityId()); competencyLevelDescriptorIds.add(helper.generateCompetencyLevelDescriptor().getEntityId()); competencyLevelDescriptorIds.add(helper.generateCompetencyLevelDescriptor().getEntityId()); assertTrue(validator.validate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, competencyLevelDescriptorIds).containsAll(competencyLevelDescriptorIds)); } @Test(expected = IllegalArgumentException.class) public void testGuards() throws Exception { validator.validate(EntityNames.STUDENT, new HashSet<String>(Arrays.asList("student1", "student2"))); }
### Question: TransitiveTeacherToStaffEdOrgAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType) && isTeacher() && isTransitive; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STAFF_ED_ORG_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STAFF_ED_ORG_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); }
### Question: TransitiveTeacherToStaffEdOrgAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STAFF_ED_ORG_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } Map<String, Set<String>> requiredEdOrgsToSEOAs = new HashMap<String, Set<String>>(); { Iterable<Entity> requestedAssociations = repo.findAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids))); for (Entity entity : requestedAssociations) { String id = (String) entity.getBody().get(ParameterConstants.EDUCATION_ORGANIZATION_REFERENCE); if (!requiredEdOrgsToSEOAs.containsKey(id)) { requiredEdOrgsToSEOAs.put(id, new HashSet<String>()); } requiredEdOrgsToSEOAs.get(id).add(entity.getEntityId()); } } Set<String> teachersEdOrgs = new HashSet<String>(); { NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_REFERENCE, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil.principalId())); Iterable<Entity> teachersAssociations = this.repo.findAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, query); for (Entity entity : teachersAssociations) { if (!dateHelper.isFieldExpired(entity.getBody(), ParameterConstants.END_DATE)) { teachersEdOrgs.add((String) entity.getBody().get(ParameterConstants.EDUCATION_ORGANIZATION_REFERENCE)); } } } return getValidIds(teachersEdOrgs, requiredEdOrgsToSEOAs); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateNonExpiredAssociation() { helper.generateStaffEdorg(helper.STAFF_ID, helper.ED_ORG_ID, false); Entity assoc = helper.generateStaffEdorg("staff2", helper.ED_ORG_ID, false); edOrgAssociationIds.add(assoc.getEntityId()); assertTrue(validator.validate(EntityNames.STAFF_ED_ORG_ASSOCIATION, edOrgAssociationIds).equals(edOrgAssociationIds)); } @Test public void testInvalidateExpiredAssociation() { helper.generateStaffEdorg(helper.STAFF_ID, helper.ED_ORG_ID, true); Entity assoc = helper.generateStaffEdorg("staff2", helper.ED_ORG_ID, false); edOrgAssociationIds.add(assoc.getEntityId()); assertFalse(validator.validate(EntityNames.STAFF_ED_ORG_ASSOCIATION, edOrgAssociationIds).equals(edOrgAssociationIds)); }
### Question: StaffToTeacherValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean through) { return EntityNames.TEACHER.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean through); @Override Set<String> validate(String entityName, Set<String> teacherIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateStaffToTeacher() throws Exception { setupCurrentUser(staff1); setupCommonTSAs(); assertTrue(validator.canValidate(EntityNames.TEACHER, true)); assertTrue(validator.canValidate(EntityNames.TEACHER, false)); }
### Question: StaffToTeacherValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityName, Set<String> teacherIds) throws IllegalStateException { if (!areParametersValid(EntityNames.TEACHER, entityName, teacherIds)) { return Collections.EMPTY_SET; } NeutralQuery basicQuery = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_REFERENCE, NeutralCriteria.CRITERIA_IN, teacherIds)); Iterable<Entity> schoolAssoc = repo.findAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, basicQuery); Map<String, Set<String>> teacherSchoolMap = new HashMap<String, Set<String>>(); populateMapFromMongoResponse(teacherSchoolMap, schoolAssoc); Set<String> edOrgLineage = getStaffEdOrgLineage(); Set<String> validTeacherIds = new HashSet<String>(); for (String teacher : teacherSchoolMap.keySet()) { Set<String> tmpSet = new HashSet<String>(teacherSchoolMap.get(teacher)); tmpSet.retainAll(edOrgLineage); if (tmpSet.size() != 0) { validTeacherIds.add(teacher); } } return validTeacherIds; } @Override boolean canValidate(String entityType, boolean through); @Override Set<String> validate(String entityName, Set<String> teacherIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testInvalidTeacherAssociation() { setupCurrentUser(staff1); setupCommonTSAs(); Set<String> teacher = new HashSet<String>(Arrays.asList(teacher2.getEntityId())); assertTrue(validator.validate(EntityNames.TEACHER, teacher).isEmpty()); } @Test public void testValidAndInvalidTeacherAssociation() { setupCurrentUser(staff1); setupCommonTSAs(); Set<String> teachers = new HashSet<String>(Arrays.asList(teacher1.getEntityId(), teacher2.getEntityId())); assertTrue(validator.validate(EntityNames.TEACHER, teachers).equals(new HashSet<String>(Arrays.asList(teacher1.getEntityId())))); } @Test public void testValidAssociationThroughSchool() { setupCurrentUser(staff2); setupCommonTSAs(); Set<String> teachers = new HashSet<String>(Arrays.asList(teacher1.getEntityId(), teacher3.getEntityId())); assertTrue(validator.validate(EntityNames.TEACHER, teachers).equals(teachers)); } @Test public void testValidAssociationThroughLEA() { setupCurrentUser(staff1); setupCommonTSAs(); Set<String> teachers = new HashSet<String>(Arrays.asList(teacher1.getEntityId(), teacher3.getEntityId())); assertTrue(validator.validate(EntityNames.TEACHER, teachers).equals(teachers)); } @Test public void testInvalidTeacher() { setupCurrentUser(staff1); setupCommonTSAs(); Set<String> teachers = new HashSet<String>(Arrays.asList(UUID.randomUUID().toString())); assertFalse(validator.validate(EntityNames.TEACHER, teachers).equals(teachers)); } @Test public void testExpiredTeacher() { setupCurrentUser(staff1); helper.generateStaffEdorg(teacher1.getEntityId(), school1.getEntityId(), true); Set<String> teacher = new HashSet<String>(Arrays.asList(teacher1.getEntityId())); assertFalse(validator.validate(EntityNames.TEACHER, teacher).equals(teacher)); helper.generateStaffEdorg(teacher1.getEntityId(), school1.getEntityId(), false); teacher = new HashSet<String>(Arrays.asList(teacher1.getEntityId())); assertTrue(validator.validate(EntityNames.TEACHER, teacher).equals(teacher)); } @Test public void testNoTeacher() { setupCurrentUser(staff1); assertTrue(validator.validate(EntityNames.TEACHER, new HashSet<String>()).isEmpty()); }
### Question: TransitiveTeacherToStaffValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean transitive) { return transitive && EntityNames.STAFF.equals(entityType) && isTeacher(); } @Override boolean canValidate(String entityType, boolean transitive); @Override Set<String> validate(String entityName, Set<String> staffIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateTeacherToStaff() throws Exception { assertTrue(validator.canValidate(EntityNames.STAFF, true)); assertFalse(validator.canValidate(EntityNames.STAFF, false)); }
### Question: TransitiveTeacherToStaffValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityName, Set<String> staffIds) throws IllegalStateException { if (!areParametersValid(EntityNames.STAFF, entityName, staffIds)) { return Collections.EMPTY_SET; } NeutralQuery basicQuery = new NeutralQuery(new NeutralCriteria("staffReference", NeutralCriteria.CRITERIA_IN, staffIds)); basicQuery.setIncludeFields(Arrays.asList("educationOrganizationReference", "staffReference")); NeutralCriteria endDateCriteria = new NeutralCriteria(ParameterConstants.END_DATE, NeutralCriteria.CRITERIA_GTE, getFilterDate(true)); basicQuery.addOrQuery(new NeutralQuery(new NeutralCriteria(ParameterConstants.END_DATE, NeutralCriteria.CRITERIA_EXISTS, false))); basicQuery.addOrQuery(new NeutralQuery(endDateCriteria)); Iterable<Entity> edOrgAssoc = repo.findAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, basicQuery); Map<String, List<String>> staffEdorgMap = new HashMap<String, List<String>>(); populateMapFromMongoResponse(staffEdorgMap, edOrgAssoc); Set<String> schools = new HashSet<String>(); schools.addAll(getDirectEdorgs()); Set<String> validStaffIds = new HashSet<String>(); for (Map.Entry entry: staffEdorgMap.entrySet()) { List<String> edorgs = (List<String>) entry.getValue(); HashSet<String> tmpSchools = new HashSet<String>(schools); tmpSchools.retainAll(edorgs); if (tmpSchools.size() != 0) { validStaffIds.add((String) entry.getKey()); } } return validStaffIds; } @Override boolean canValidate(String entityType, boolean transitive); @Override Set<String> validate(String entityName, Set<String> staffIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testInvalidTeacherStaffAssociation() { Set<String> ids = new HashSet<String>(Arrays.asList(staff1.getEntityId())); assertFalse(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testValidTeacherStaffAssociationNoEndDate() { Set<String> ids = new HashSet<String>(Arrays.asList(staff2.getEntityId())); assertTrue(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testValidTeacherStaffAssociationWithEndDate() { Set<String> ids = new HashSet<String>(Arrays.asList(staff3.getEntityId())); assertTrue(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testExpiredTeacherStaffAssociation() { Set<String> ids = new HashSet<String>(Arrays.asList(staff4.getEntityId())); assertFalse(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testStaffWithNoEdorgAssociation() { Set<String> ids = new HashSet<String>(Arrays.asList(staff2.getEntityId(), staff5.getEntityId())); assertFalse(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testMulti1() { Set<String> ids = new HashSet<String>(Arrays.asList(staff1.getEntityId(), staff2.getEntityId(), staff3.getEntityId(), staff4.getEntityId())); assertFalse(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testMulti2() { Set<String> ids = new HashSet<String>(Arrays.asList(staff1.getEntityId(), staff4.getEntityId())); assertFalse(validator.validate(EntityNames.STAFF, ids).equals(ids)); } @Test public void testMulti3() { Set<String> ids = new HashSet<String>(Arrays.asList(staff2.getEntityId(), staff3.getEntityId())); assertTrue(validator.validate(EntityNames.STAFF, ids).equals(ids)); }
### Question: StudentToStudentParentAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { Set<String> validIds = new HashSet<String>(); if (!areParametersValid(EntityNames.STUDENT_PARENT_ASSOCIATION, entityType, ids)) { return Collections.emptySet(); } Entity entity = SecurityUtil.getSLIPrincipal().getEntity(); List<Entity> elist = entity.getEmbeddedData().get("studentParentAssociation"); if (elist != null ) { for (Entity e : elist) { validIds.add(e.getEntityId()); } } validIds.retainAll(ids); return validIds; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testValidStudentParentAssociation() { Set<String> ids = new HashSet<String>(); for (Entity e : studentParentAssociationList) { String s = e.getEntityId(); ids.add(s); } boolean valid = validator.validate(EntityNames.STUDENT_PARENT_ASSOCIATION, ids).containsAll(ids); Assert.assertTrue(valid); } @Test public void testOneInvalidStudentParentAssociation() { Set<String> ids = new HashSet<String>(); for (Entity e : studentParentAssociationList) { String s = e.getEntityId(); ids.add(s); } ids.add("invalidID"); boolean valid = validator.validate(EntityNames.STUDENT_PARENT_ASSOCIATION, ids).containsAll(ids); Assert.assertTrue(!valid); } @Test public void testEmptyStudentParentAssociation() { Set<String> ids = new HashSet<String>(); ids.add("invalidID"); boolean valid = validator.validate(EntityNames.STUDENT_PARENT_ASSOCIATION, ids).containsAll(ids); Assert.assertTrue(!valid); }
### Question: GenericToGlobalClassPeriodWriteValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.CLASS_PERIOD, entityType, ids)) { return Collections.emptySet(); } Set<String> edOrgLineage = getEdorgDescendents(getDirectEdorgs()); NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids, false)); query.addCriteria(new NeutralCriteria(ParameterConstants.EDUCATION_ORGANIZATION_ID, NeutralCriteria.CRITERIA_IN, edOrgLineage)); return Sets.newHashSet(getRepo().findAllIds(entityType, query)); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testFilterClassPeriodDataFromLEA() { setupStaff(staffLea, lea.getEntityId()); Set<String> expectedIds = new HashSet<String>(Arrays.asList(classPeriodLea.getEntityId(), classPeriodSchoolLea.getEntityId())); Set<String> actual = validator.validate(EntityNames.CLASS_PERIOD, classPeriodIds); Assert.assertEquals(expectedIds, actual); } @Test public void testFilterClassPeriodDataFromSchool() { setupStaff(staffSchoolLea, schoolParentLea.getEntityId()); Set<String> expectedIds = new HashSet<String>(Arrays.asList(classPeriodSchoolLea.getEntityId())); Set<String> actual = validator.validate(EntityNames.CLASS_PERIOD, classPeriodIds); Assert.assertEquals(expectedIds, actual); } @Test public void testFilterClassPeriodDataFromSchool2() { setupStaff(staffSchoolNoParent, schoolNoParent.getEntityId()); Set<String> expectedIds = new HashSet<String>(Arrays.asList(classPeriodSchoolNoParent.getEntityId())); Set<String> actual = validator.validate(EntityNames.CLASS_PERIOD, classPeriodIds); Assert.assertEquals(expectedIds, actual); }
### Question: TeacherToStudentCohortAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STUDENT_COHORT_ASSOCIATION.equals(entityType) && isTeacher(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { setupCurrentUser(teacher1); Assert.assertTrue(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, false)); Assert.assertTrue(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, true)); injector.setStaffContext(); SecurityUtil.setUserContext(SecurityUtil.UserContext.STAFF_CONTEXT); Assert.assertFalse(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, false)); Assert.assertFalse(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, true)); }
### Question: LandingZoneProcessor implements Processor { @Override public void process(Exchange exchange) throws Exception { Stage stage = Stage.createAndStartStage(LZ_STAGE, LZ_STAGE_DESC); String batchJobId = null; ReportStats reportStats = new SimpleReportStats(); NewBatchJob currentJob = null; File lzFile = exchange.getIn().getHeader("filePath", File.class); boolean hasErrors = false; String lzDirectoryPathName = lzFile.getParent(); if (!isValidLandingZone(lzDirectoryPathName)) { hasErrors = true; LOG.error("LandingZoneProcessor: {} is not a valid landing zone.", lzDirectoryPathName); reportStats.incError(); } else { currentJob = createNewBatchJob(lzFile); createResourceEntryAndAddToJob(lzFile, currentJob); batchJobId = currentJob.getId(); String lzFileName = lzFile.getName(); if (!isZipFile(lzFileName)) { hasErrors = true; handleProcessingError(exchange, batchJobId, lzFileName, lzDirectoryPathName, reportStats); } BatchJobUtils.stopStageAndAddToJob(stage, currentJob); batchJobDAO.saveBatchJob(currentJob); } setExchangeBody(exchange, reportStats, currentJob, hasErrors); } @Override void process(Exchange exchange); static final BatchJobStageType LZ_STAGE; }### Answer: @Test public void testValidLz() throws Exception { File validLzPathFile = new File("/test/lz/inbound/TEST-LZ/testFile.zip"); String validLzPathname = validLzPathFile.getParent(); List<String> testLzPaths = new ArrayList<String>(); testLzPaths.add(validLzPathname); when(mockedTenantDA.getLzPaths()).thenReturn(testLzPaths); Exchange exchange = new DefaultExchange(new DefaultCamelContext()); exchange.getIn().setHeader("filePath", validLzPathFile.getPath()); landingZoneProcessor.process(exchange); assertFalse("Header on exchange should indicate success", exchange.getIn().getBody(WorkNote.class).hasErrors()); } @Test public void testInvalidLz() throws Exception { File validLzPathFile = new File("/test/lz/inbound/TEST-LZ/testFile.zip"); String validLzPathname = validLzPathFile.getParent(); List<String> testLzPaths = new ArrayList<String>(); testLzPaths.add(validLzPathname); when(mockedTenantDA.getLzPaths()).thenReturn(testLzPaths); File inValidLzPathFile = new File("/test/lz/inbound/BAD-TEST-LZ/testFile.zip"); Exchange exchange = new DefaultExchange(new DefaultCamelContext()); exchange.getIn().setHeader("filePath", inValidLzPathFile.getPath()); landingZoneProcessor.process(exchange); assertTrue("Header on exchange should indicate failure", exchange.getIn().getBody(WorkNote.class).hasErrors()); } @Test public void testNonZipFileInLz() throws Exception { File unzippedLzPathFile = new File("/test/lz/inbound/TEST-LZ/testFile.ctl"); String validLzPathname = unzippedLzPathFile.getParent(); List<String> testLzPaths = new ArrayList<String>(); testLzPaths.add(validLzPathname); when(mockedTenantDA.getLzPaths()).thenReturn(testLzPaths); Exchange exchange = new DefaultExchange(new DefaultCamelContext()); exchange.getIn().setHeader("filePath", unzippedLzPathFile.getPath()); landingZoneProcessor.process(exchange); assertTrue("Header on exchange should indicate failure", exchange.getIn().getBody(WorkNote.class).hasErrors()); }
### Question: StudentDenyAllValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStudentOrParent() && (STUDENT_DENIED_ENTITIES.contains(entityType) \|\| (isTransitive && EntityNames.isPublic(entityType)) \|\| (!isTransitive && NON_TRANSITIVE_DENY_ALL .contains(entityType))); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.DISCIPLINE_ACTION, true)); assertTrue(validator.canValidate(EntityNames.DISCIPLINE_ACTION, false)); assertTrue(validator.canValidate(EntityNames.DISCIPLINE_INCIDENT, true)); assertTrue(validator.canValidate(EntityNames.DISCIPLINE_INCIDENT, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_DISCIPLINE_INCIDENT_ASSOCIATION, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_DISCIPLINE_INCIDENT_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_GRADEBOOK_ENTRY, false)); assertTrue(validator.canValidate(EntityNames.PROGRAM, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, false)); }
### Question: StudentDenyAllValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { return Collections.emptySet(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testValidate() { Assert.assertEquals(Collections.emptySet(), validator.validate(null, null)); Assert.assertEquals(Collections.emptySet(), validator.validate(new String(), new HashSet<String>())); }
### Question: TeacherToStudentProgramAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STUDENT_PROGRAM_ASSOCIATION.equals(entityType) && isTeacher(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { Assert.assertTrue(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, false)); Assert.assertTrue(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, true)); }
### Question: TeacherToStudentProgramAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STUDENT_PROGRAM_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery query = new NeutralQuery( new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); query.setIncludeFields(Arrays.asList(ParameterConstants.PROGRAM_ID)); Map<String, Set<String>> programIdsToSPA = new HashMap<String, Set<String>>(); Iterable<Entity> spas = getRepo().findAll(EntityNames.STUDENT_PROGRAM_ASSOCIATION, query); for (Entity spa : spas) { String programId = (String) spa.getBody().get(ParameterConstants.PROGRAM_ID); if (!programIdsToSPA.containsKey(programId)) { programIdsToSPA.put(programId, new HashSet<String>()); } programIdsToSPA.get(programId).add(spa.getEntityId()); } String teacherId = SecurityUtil.getSLIPrincipal().getEntity().getEntityId(); NeutralQuery nq = new NeutralQuery(new NeutralCriteria(ParameterConstants.PROGRAM_ID, NeutralCriteria.CRITERIA_IN, programIdsToSPA.keySet())); nq.addCriteria(new NeutralCriteria(ParameterConstants.STAFF_ID, NeutralCriteria.OPERATOR_EQUAL, teacherId)); nq.addCriteria(new NeutralCriteria(ParameterConstants.STUDENT_RECORD_ACCESS, NeutralCriteria.OPERATOR_EQUAL, true)); Iterable<Entity> entities = getRepo().findAll(EntityNames.STAFF_PROGRAM_ASSOCIATION, nq); Set<String> validProgramIds = new HashSet<String>(); for (Entity entity : entities) { String expireDate = (String) entity.getBody().get(ParameterConstants.END_DATE); if (expireDate == null \|\| isLhsBeforeRhs(getNowMinusGracePeriod(), getDateTime(expireDate))) { validProgramIds.add((String) entity.getBody().get(ParameterConstants.PROGRAM_ID)); } } return getValidIds(validProgramIds, programIdsToSPA); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidAccessTeacher() { Set<String> ids = new HashSet<String>(Arrays.asList(studentProgramAssoc1.getEntityId())); Assert.assertTrue(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, ids).equals(ids)); } @Test public void testInvalidAccessTeacher1() { Set<String> ids = new HashSet<String>(Arrays.asList(studentProgramAssoc2.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(studentProgramAssoc3.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(studentProgramAssoc4.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(studentProgramAssoc5.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, ids).equals(ids)); ids = new HashSet<String>( Arrays.asList(studentProgramAssoc1.getEntityId(), studentProgramAssoc3.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, ids).equals(ids)); }
### Question: TeacherToDisciplineIncidentValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTeacher() && EntityNames.DISCIPLINE_INCIDENT.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.DISCIPLINE_INCIDENT, true)); assertTrue(validator.canValidate(EntityNames.DISCIPLINE_INCIDENT, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); }
### Question: TeacherToDisciplineIncidentValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.DISCIPLINE_INCIDENT, entityType, ids)) { return Collections.EMPTY_SET; } Set<String> discIncidentIds = new HashSet<String>(ids); String myself = SecurityUtil.getSLIPrincipal().getEntity().getEntityId(); NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, discIncidentIds)); query.addCriteria(new NeutralCriteria(ParameterConstants.STAFF_ID, NeutralCriteria.OPERATOR_EQUAL, myself)); Iterable<Entity> incidents = getRepo().findAll(EntityNames.DISCIPLINE_INCIDENT, query); for (Entity ent : incidents) { discIncidentIds.remove(ent.getEntityId()); } if (discIncidentIds.size() == 0) { return ids; } query = new NeutralQuery(new NeutralCriteria(ParameterConstants.DISCIPLINE_INCIDENT_ID, NeutralCriteria.CRITERIA_IN, discIncidentIds)); query.setIncludeFields(Arrays.asList(ParameterConstants.STUDENT_ID, ParameterConstants.DISCIPLINE_INCIDENT_ID)); Iterable<Entity> assocs = getRepo().findAll(EntityNames.STUDENT_DISCIPLINE_INCIDENT_ASSOCIATION, query); Map<String, Set<String>> discIncToStudents = new HashMap<String, Set<String>>(); for (Entity assoc : assocs) { String studentId = (String) assoc.getBody().get(ParameterConstants.STUDENT_ID); String discIncId = (String) assoc.getBody().get(ParameterConstants.DISCIPLINE_INCIDENT_ID); Set<String> studentList = discIncToStudents.get(discIncId); if (studentList == null) { studentList = new HashSet<String>(); discIncToStudents.put(discIncId, studentList); } studentList.add(studentId); } Set<String> validIncidents = new HashSet<String>(ids); validIncidents.removeAll(discIncidentIds); for (String discIncId : discIncToStudents.keySet()) { Set<String> validStudent = studentValidator.validate(EntityNames.STUDENT, discIncToStudents.get(discIncId)); if (validStudent.size() > 0) { validIncidents.add(discIncId); } } return validIncidents; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidIncident() { Set<String> ids = list(disciplineIncident1.getEntityId()); assertTrue(validator.validate(EntityNames.DISCIPLINE_INCIDENT, ids).equals(ids)); ids = list(disciplineIncident2.getEntityId()); assertTrue(validator.validate(EntityNames.DISCIPLINE_INCIDENT, ids).equals(ids)); ids = list(disciplineIncident1.getEntityId(), disciplineIncident2.getEntityId()); assertTrue(validator.validate(EntityNames.DISCIPLINE_INCIDENT, ids).equals(ids)); ids = list(disciplineIncident4.getEntityId()); assertTrue(validator.validate(EntityNames.DISCIPLINE_INCIDENT, ids).equals(ids)); } @Test public void testInvalidIncident() { Set<String> ids = list(disciplineIncident3.getEntityId()); assertFalse(validator.validate(EntityNames.DISCIPLINE_INCIDENT, ids).equals(ids)); ids = list(disciplineIncident3.getEntityId(), disciplineIncident1.getEntityId()); assertFalse(validator.validate(EntityNames.DISCIPLINE_INCIDENT, ids).equals(ids)); }
### Question: StaffToSubStudentEntityValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean through) { return isStaff() && isSubEntityOfStudent(entityType); } @Override boolean canValidate(String entityType, boolean through); @SuppressWarnings("unchecked") @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateStaffToReportCard() { assertTrue(validator.canValidate(EntityNames.REPORT_CARD, false)); } @Test public void testCanValidateStaffToAttendance() throws Exception { assertTrue(validator.canValidate(EntityNames.ATTENDANCE, false)); } @Test public void testCanValidateStaffToDisciplineAction() throws Exception { assertTrue(validator.canValidate(EntityNames.DISCIPLINE_ACTION, false)); } @Test public void testCanValidateStaffToStudentAcademicRecord() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_ACADEMIC_RECORD, false)); } @Test public void testCanValidateStaffToStudentAssessment() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_ASSESSMENT, false)); } @Test public void testCanValidateStaffToStudentDisciplineIncident() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_DISCIPLINE_INCIDENT_ASSOCIATION, false)); } @Test public void testCanValidateStaffToStudentGradebookEntry() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_GRADEBOOK_ENTRY, false)); } @Test public void testCanValidateStaffToStudentParentAssociation() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_PARENT_ASSOCIATION, false)); } @Test public void testCanValidateStaffToStudentSchoolAssociation() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, false)); } @Test public void testCanValidateStaffToStudentSectionAssociation() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, false)); } @Test public void testCanNotValidateOtherEntities() throws Exception { assertFalse(validator.canValidate(EntityNames.STUDENT, false)); }
### Question: StudentToStudentCompetencyValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStudentOrParent() && EntityNames.STUDENT_COMPETENCY.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STUDENT_COMPETENCY, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_COMPETENCY, false)); assertFalse(validator.canValidate(EntityNames.GRADEBOOK_ENTRY, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_COMPETENCY_OBJECTIVE, true)); }
### Question: ControlFileProcessor implements Processor { @Override public void process(Exchange exchange) throws Exception { processUsingNewBatchJob(exchange); MongoTrackingAspect.aspectOf().reset(); } @Override void process(Exchange exchange); static final BatchJobStageType BATCH_JOB_STAGE; }### Answer: @Test public void shouldAcceptExchangeObjectReadExchangeControlFileAndSetExchangeBatchJob() throws Exception { Exchange preObject = new DefaultExchange(new DefaultCamelContext()); WorkNote workNote = Mockito.mock(WorkNote.class); String batchJobId = NewBatchJob.createId("InterchangeStudentCsv.ctl"); NewBatchJob mockedJob = Mockito.mock(NewBatchJob.class); Mockito.when(mockedJob.getBatchProperties()).thenReturn(new HashMap <String, String>()); Mockito.when(workNote.getBatchJobId()).thenReturn(batchJobId); Mockito.when(mockedBatchJobDAO.findBatchJobById(Matchers.eq(batchJobId))).thenReturn(mockedJob); preObject.getIn().setBody(workNote); processor.process(preObject); boolean hasErrors = (Boolean) preObject.getIn().getHeader("hasErrors"); assertNotNull("header [hasErrors] not set", hasErrors); }
### Question: StudentToStudentCompetencyValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STUDENT_COMPETENCY, entityType, ids)) { return Collections.emptySet(); } Map<String, Set<String>> ssaToSC = getIdsContainedInFieldOnEntities(entityType, new ArrayList<String>( ids), ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); if (ssaToSC.isEmpty()) { return Collections.emptySet(); } Map<String, Set<String>> studentIdsToSSA = getIdsContainedInFieldOnEntities(EntityNames.STUDENT_SECTION_ASSOCIATION, new ArrayList<String>(ssaToSC.keySet()), ParameterConstants.STUDENT_ID); if (studentIdsToSSA.isEmpty()) { return Collections.emptySet(); } Set<String> studentIds = studentIdsToSSA.keySet(); studentIds.retainAll(getDirectStudentIds()); Set<String> validSSAIds = getValidIds(studentIds, studentIdsToSSA); Set<String> validSCIds = getValidIds(validSSAIds, ssaToSC); return validSCIds; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testSingleValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(competency1.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_COMPETENCY, idsToValidate).containsAll(idsToValidate)); } @Test public void testNegativeHeterogeneousValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(competency1.getEntityId(),competency2.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_COMPETENCY, idsToValidate).containsAll(idsToValidate)); }
### Question: TeacherToStaffEdOrgAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STAFF_ED_ORG_ASSOCIATION.equals(entityType) && isTeacher() && !isTransitive; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STAFF_ED_ORG_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STAFF_ED_ORG_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); }
### Question: TeacherToStaffEdOrgAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STAFF_ED_ORG_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_REFERENCE, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil.principalId())); Iterable<Entity> entities = this.repo.findAll(EntityNames.STAFF_ED_ORG_ASSOCIATION, query); Set<String> validIds = new HashSet<String>(); for (Entity entity : entities) { if (!dateHelper.isFieldExpired(entity.getBody(), ParameterConstants.END_DATE)) { validIds.add(entity.getEntityId()); } } validIds.retainAll(ids); return validIds; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateNonExpiredAssociation() { Set<String> edOrgAssociationIds = new HashSet<String>(); Entity assoc = helper.generateStaffEdorg(helper.STAFF_ID, helper.ED_ORG_ID, false); edOrgAssociationIds.add(assoc.getEntityId()); assertTrue(validator.validate(EntityNames.STAFF_ED_ORG_ASSOCIATION, edOrgAssociationIds).containsAll(edOrgAssociationIds)); } @Test public void testInvalidateExpiredAssociation() { Set<String> edOrgAssociationIds = new HashSet<String>(); Entity assoc = helper.generateStaffEdorg(helper.STAFF_ID, helper.ED_ORG_ID, true); edOrgAssociationIds.add(assoc.getEntityId()); assertFalse(validator.validate(EntityNames.STAFF_ED_ORG_ASSOCIATION, edOrgAssociationIds).containsAll(edOrgAssociationIds)); }
### Question: StudentToStudentSectionAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStudentOrParent() && EntityNames.STUDENT_SECTION_ASSOCIATION.equals(entityType) && !isTransitive; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, false)); assertFalse(validator.canValidate(EntityNames.ASSESSMENT, true)); assertFalse(validator.canValidate(EntityNames.GRADEBOOK_ENTRY, true)); assertFalse(validator.canValidate(EntityNames.COHORT, true)); assertFalse(validator.canValidate(EntityNames.STAFF_COHORT_ASSOCIATION, false)); }
### Question: StudentToStudentSectionAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STUDENT_SECTION_ASSOCIATION, entityType, ids)) { return Collections.emptySet(); } NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); for(Entity ssa : getRepo().findAll(EntityNames.STUDENT_SECTION_ASSOCIATION, query)) { Map<String, Object> body = ssa.getBody(); if (!getDirectStudentIds().contains(body.get(ParameterConstants.STUDENT_ID))) { return Collections.emptySet(); } } return ids; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testPositiveValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(assoc1Current.getEntityId(), assoc1Past.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_SECTION_ASSOCIATION, idsToValidate).containsAll(idsToValidate)); } @Test public void testHeterogeneousValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(assoc1Current.getEntityId(), assoc2.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_SECTION_ASSOCIATION, idsToValidate).containsAll(idsToValidate)); }
### Question: StaffToStudentCohortProgramAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return STUDENT_ASSOCIATIONS.contains(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.SECTION, true)); assertFalse(validator.canValidate(EntityNames.SECTION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, false)); }
### Question: StaffToStudentCohortProgramAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(STUDENT_ASSOCIATIONS, entityType, ids)) { return Collections.EMPTY_SET; } Map<String, Set<String>> associations = new HashMap<String, Set<String>>(); NeutralQuery basicQuery = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); Iterable<Entity> assocs = getRepo().findAll(entityType, basicQuery); for (Entity assoc : assocs) { String studentId = (String) assoc.getBody().get(ParameterConstants.STUDENT_ID); if (!isFieldExpired(assoc.getBody(), ParameterConstants.END_DATE, true)) { if (!associations.containsKey(studentId)) { associations.put(studentId, new HashSet<String>()); } associations.get(studentId).add(assoc.getEntityId()); } } Set<String> validStudents = studentValidator.validate(EntityNames.STUDENT, associations.keySet()); return getValidIds(validStudents, associations); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateValidCohortAssociation() { Mockito.when(mockStudentValidator.validate(Mockito.eq(EntityNames.STUDENT), Mockito.any(Set.class))) .thenReturn(new HashSet<String>(Arrays.asList("Boop"))); for (int i = 0; i < 10; ++i) { cohortIds.add(helper.generateStudentCohort("Boop", "" + i, false).getEntityId()); } assertTrue(validator.validate(EntityNames.STUDENT_COHORT_ASSOCIATION, cohortIds).equals(cohortIds)); } @Test public void testCanValidateValidProgramAssociation() { Mockito.when(mockStudentValidator.validate(Mockito.eq(EntityNames.STUDENT), Mockito.any(Set.class))) .thenReturn(new HashSet<String>(Arrays.asList("Boop"))); for (int i = 0; i < 10; ++i) { programIds.add(helper.generateStudentProgram("Boop", "" + i, false).getEntityId()); } assertTrue(validator.validate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, programIds).equals(programIds)); } @Test public void testCanNotValidExpiredAssociation() { Mockito.when(mockStudentValidator.validate(Mockito.eq(EntityNames.STUDENT), Mockito.any(Set.class))) .thenReturn(new HashSet<String>(Arrays.asList("Boop"))); cohortIds.add(helper.generateStudentCohort("Boop", "Beep", true).getEntityId()); assertFalse(validator.validate(EntityNames.STUDENT_COHORT_ASSOCIATION, cohortIds).equals(cohortIds)); } @Test public void testCanNotValidateAssociationWithoutStudentAccess() { Mockito.when(mockStudentValidator.validate(Mockito.eq(EntityNames.STUDENT), Mockito.any(Set.class))) .thenReturn(new HashSet<String>(Arrays.asList("dummy"))); for (int i = 0; i < 10; ++i) { cohortIds.add(helper.generateStudentCohort("Boop", "" + i, false).getEntityId()); } assertFalse(validator.validate(EntityNames.STUDENT_COHORT_ASSOCIATION, cohortIds).equals(cohortIds)); }
### Question: TenantProcessor implements Processor { @Override public void process(Exchange exchange) throws Exception { try { createNewLandingZones(); exchange.getIn().setHeader(TENANT_POLL_HEADER, TENANT_POLL_SUCCESS); doPreloads(); } catch (Exception e) { exchange.getIn().setHeader(TENANT_POLL_HEADER, TENANT_POLL_FAILURE); LOG.error("Exception encountered adding tenant", e); } } @Override void process(Exchange exchange); static final String TENANT_POLL_HEADER; static final String TENANT_POLL_SUCCESS; static final String TENANT_POLL_FAILURE; }### Answer: @Test public void shouldAddNewLz() throws Exception { List<String> testLzPaths = new ArrayList<String>(); testLzPaths.add("."); when(mockedTenantDA.getLzPaths()).thenReturn(testLzPaths); Exchange exchange = new DefaultExchange(new DefaultCamelContext()); tenantProcessor.process(exchange); assertEquals("Header on exchange should indicate success", TenantProcessor.TENANT_POLL_SUCCESS, exchange .getIn().getHeader(TenantProcessor.TENANT_POLL_HEADER)); }
### Question: TransitiveStaffToStaffValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean transitive) { return transitive && EntityNames.STAFF.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean transitive); @SuppressWarnings("unchecked") @Override Set<String> validate(String entityName, Set<String> staffIds); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateTeacherToStaff() throws Exception { setupCurrentUser(staff1); assertTrue(validator.canValidate(EntityNames.STAFF, true)); assertFalse(validator.canValidate(EntityNames.STAFF, false)); assertFalse(validator.canValidate(EntityNames.SECTION, false)); assertFalse(validator.canValidate(EntityNames.SECTION, true)); }
### Question: TenantProcessor implements Processor { boolean preLoad(String landingZone, List<String> dataSets) { File landingZoneDir = new File(landingZone); if (!landingZoneDir.exists()) { try { FileUtils.forceMkdir(landingZoneDir); } catch (IOException e) { LOG.error("TenantProcessor: Failed to create landing zone: {} with absolute path {}", landingZone, landingZoneDir.getAbsolutePath()); return false; } } if (landingZoneDir.exists() && landingZoneDir.isDirectory()) { boolean result = true; for (String dataSet : dataSets) { List<String> fileNames = getDataSetLookup().get(dataSet); if (fileNames != null) { for (String fileName : fileNames) { URL fileLocation = Thread.currentThread().getContextClassLoader().getResource(fileName); try { InputStream sampleFile = fileLocation == null ? new FileInputStream(fileName) : fileLocation.openStream(); result &= sendToLandingZone(landingZoneDir, sampleFile); } catch (FileNotFoundException e) { LOG.error("sample data set {} doesn't exists", fileName); result = false; } catch (IOException e) { LOG.error("error loading sample data set", e); } } } else { result = false; } } return result; } return false; } @Override void process(Exchange exchange); static final String TENANT_POLL_HEADER; static final String TENANT_POLL_SUCCESS; static final String TENANT_POLL_FAILURE; }### Answer: @Test public void testPreLoad() { File landingZone = Files.createTempDir(); try { assertTrue(tenantProcessor.preLoad(landingZone.getAbsolutePath(), Arrays.asList("small"))); assertTrue(landingZone.list(new WildcardFileFilter("preload-*.zip")).length == 1); } finally { landingZone.delete(); } } @Test public void testPreLoadBadDataSet() { File landingZone = Files.createTempDir(); try { assertTrue(!tenantProcessor.preLoad(landingZone.getAbsolutePath(), Arrays.asList("smallish"))); } finally { landingZone.delete(); } }
### Question: GenericToGlobalBellScheduleWriteValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.BELL_SCHEDULE, entityType, ids)) { return Collections.emptySet(); } Set<String> edOrgLineage = getEdorgDescendents(getDirectEdorgs()); NeutralQuery classPeriodsQuery = new NeutralQuery(); classPeriodsQuery.addCriteria(new NeutralCriteria(ParameterConstants.EDUCATION_ORGANIZATION_ID, NeutralCriteria.CRITERIA_IN, edOrgLineage)); List<String> myClassPeriods = Lists.newArrayList(getRepo().findAllIds("classPeriod", classPeriodsQuery)); NeutralQuery bellSchedulesQuery = new NeutralQuery(); bellSchedulesQuery.addCriteria(new NeutralCriteria("meetingTime.classPeriodId", NeutralCriteria.CRITERIA_IN, myClassPeriods)); bellSchedulesQuery.addCriteria(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids, false)); Set<String> myBellSchedules = Sets.newHashSet(getRepo().findAllIds("bellSchedule", bellSchedulesQuery)); return myBellSchedules; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testFilterbellScheduleDataFromLEA() { setupStaff(staffLea, lea.getEntityId()); Set<String> expectedIds = new HashSet<String>(Arrays.asList(bellScheduleLea.getEntityId(), bellScheduleSchoolLea.getEntityId())); Set<String> actual = validator.validate(EntityNames.BELL_SCHEDULE, bellScheduleIds); Assert.assertEquals(expectedIds, actual); } @Test public void testFilterClassPeriodDataFromSchool() { setupStaff(staffSchoolLea, schoolParentLea.getEntityId()); Set<String> expectedIds = new HashSet<String>(Arrays.asList(bellScheduleSchoolLea.getEntityId())); Set<String> actual = validator.validate(EntityNames.BELL_SCHEDULE, bellScheduleIds); Assert.assertEquals(expectedIds, actual); } @Test public void testFilterClassPeriodDataFromSchool2() { setupStaff(staffSchoolNoParent, schoolNoParent.getEntityId()); Set<String> expectedIds = new HashSet<String>(Arrays.asList(bellScheduleSchoolNoParent.getEntityId())); Set<String> actual = validator.validate(EntityNames.BELL_SCHEDULE, bellScheduleIds); Assert.assertEquals(expectedIds, actual); }
### Question: TeacherToStudentValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean through) { return EntityNames.STUDENT.equals(entityType) && isTeacher(); } @Override boolean canValidate(String entityType, boolean through); @Override Set<String> validate(String entityName, Set<String> ids); @Override Set<String> getValid(String entityType, Set<String> ids); @Override void setRepo(PagingRepositoryDelegate<Entity> repo); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateTeacherToStudent() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT, false)); } @Test public void testCanNotValidateOtherEntities() throws Exception { assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); }
### Question: EdFiParserProcessor extends IngestionProcessor<FileEntryWorkNote, IngestionFileEntry> implements RecordVisitor { @Override protected void process(Exchange exchange, ProcessorArgs<FileEntryWorkNote> args) { prepareState(exchange, args.workNote); Source source = new FileSource(args.workNote.getFileEntry().getResourceId()); Metrics metrics = Metrics.newInstance(args.workNote.getFileEntry().getResourceId()); InputStream input = null; boolean validData = true; try { input = args.workNote.getFileEntry().getFileStream(); Resource xsdSchema = xsdSelector.provideXsdResource(args.workNote.getFileEntry()); parse(input, xsdSchema, args.reportStats, source); metrics.setValidationErrorCount(ignoredRecordCount.get()); } catch (IOException e) { getMessageReport().error(args.reportStats, source, CoreMessageCode.CORE_0061); } catch (SAXException e) { getMessageReport().error(args.reportStats, source, CoreMessageCode.CORE_0062); } catch (XmlParseException e) { getMessageReport().error(args.reportStats, source, CoreMessageCode.CORE_0063); validData = false; } finally { IOUtils.closeQuietly(input); if (validData) { sendDataBatch(); } cleanUpState(); args.job = refreshjob(args.job.getId()); args.stage.addMetrics(metrics); } } @Override void visit(RecordMeta recordMeta, Map<String, Object> record); @Override void ignored(); void sendDataBatch(); @Override AbstractMessageReport getMessageReport(); @Override void setMessageReport(AbstractMessageReport messageReport); @Override String getStageDescription(); @Override BatchJobStageType getStage(); ProducerTemplate getProducer(); void setProducer(ProducerTemplate producer); TypeProvider getTypeProvider(); void setTypeProvider(TypeProvider typeProvider); XsdSelector getXsdSelector(); void setHelper( ReferenceHelper helper ); void setXsdSelector(XsdSelector xsdSelector); int getBatchSize(); void setBatchSize(int batchSize); void audit(SecurityEvent event); }### Answer: @Test public void testProcess() throws Exception { init(); Exchange exchange = createFileEntryExchange(); Resource xsd = Mockito.mock(Resource.class); Map<String, Resource> xsdList = new HashMap<String, Resource>(); FileEntryWorkNote workNote = (FileEntryWorkNote) exchange.getIn().getMandatoryBody(WorkNote.class); xsdList.put(workNote.getFileEntry().getFileType().getName(), xsd); xsdSelector.setXsdList(xsdList); processor.process(exchange); Mockito.verify(processor, Mockito.times(1)).parse(Mockito.any(InputStream.class), Mockito.any(Resource.class), Mockito.any(SimpleReportStats.class), Mockito.any(JobSource.class)); }
### Question: EdFiParserProcessor extends IngestionProcessor<FileEntryWorkNote, IngestionFileEntry> implements RecordVisitor { @Override public void visit(RecordMeta recordMeta, Map<String, Object> record) { state.get().addToBatch(recordMeta, record, typeProvider, helper); if (state.get().getDataBatch().size() >= batchSize) { sendDataBatch(); } } @Override void visit(RecordMeta recordMeta, Map<String, Object> record); @Override void ignored(); void sendDataBatch(); @Override AbstractMessageReport getMessageReport(); @Override void setMessageReport(AbstractMessageReport messageReport); @Override String getStageDescription(); @Override BatchJobStageType getStage(); ProducerTemplate getProducer(); void setProducer(ProducerTemplate producer); TypeProvider getTypeProvider(); void setTypeProvider(TypeProvider typeProvider); XsdSelector getXsdSelector(); void setHelper( ReferenceHelper helper ); void setXsdSelector(XsdSelector xsdSelector); int getBatchSize(); void setBatchSize(int batchSize); void audit(SecurityEvent event); }### Answer: @Test public void testVisitAndSend() throws Exception { init(); Exchange exchange = createFileEntryExchange(); processor.setUpState(exchange, exchange.getIn().getBody(FileEntryWorkNote.class)); RecordMetaImpl meta = new RecordMetaImpl("student", "student"); Location loc = Mockito.mock(Location.class); Mockito.when(loc.getLineNumber()).thenReturn(1); Mockito.when(loc.getColumnNumber()).thenReturn(1); meta.setSourceStartLocation(loc); meta.setSourceEndLocation(loc); Map<String, Object> body = new HashMap<String, Object>(); body.put("studentUniqueStateId", "studentId"); processor.visit(meta, body); ParserState state = processor.getState(); List<NeutralRecord> records = state.getDataBatch(); Assert.assertNotNull(records); Assert.assertEquals(1, records.size()); Assert.assertEquals("studentId", records.get(0).getAttributes().get("studentUniqueStateId")); Assert.assertEquals("student", records.get(0).getRecordType()); }
### Question: StaffToSubStudentSectionAssociationEntityValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean through) { return isStaff() && isSubEntityOfStudentSectionAssociation(entityType); } @Override boolean canValidate(String entityType, boolean through); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateStaffToGrade() throws Exception { assertTrue(validator.canValidate(EntityNames.GRADE, false)); assertTrue(validator.canValidate(EntityNames.GRADE, true)); } @Test public void testCanValidateStaffToStudentCompetency() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_COMPETENCY, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_COMPETENCY, true)); } @Test public void testDeniedStaffToOtherEntity() throws Exception { assertFalse(validator.canValidate(EntityNames.STUDENT, false)); assertFalse(validator.canValidate(EntityNames.STUDENT, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_COMPETENCY_OBJECTIVE, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_COMPETENCY_OBJECTIVE, true)); }
### Question: StudentToStudentAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStudent() && STUDENT_ASSOCIATIONS.contains(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, false)); assertFalse(validator.canValidate(EntityNames.ASSESSMENT, true)); assertFalse(validator.canValidate(EntityNames.GRADEBOOK_ENTRY, true)); assertFalse(validator.canValidate(EntityNames.COHORT, true)); assertFalse(validator.canValidate(EntityNames.STAFF_COHORT_ASSOCIATION, false)); }
### Question: ControlFilePreProcessor implements Processor { @Override public void process(Exchange exchange) throws Exception { processUsingNewBatchJob(exchange); } @Override void process(Exchange exchange); Set<String> getShardCollections(); void setShardCollections(Set<String> shardCollections); void setBatchJobDAO(BatchJobDAO batchJobDAO); void setTenantDA(TenantDA tenantDA); static final BatchJobStageType BATCH_JOB_STAGE; static final String INDEX_SCRIPT; }### Answer: @Test public void testProcess() throws Exception { List<Stage> mockedStages = createFakeStages(); Map<String, String> mockedProperties = createFakeBatchProperties(); File testZip = IngestionTest.getFile("ctl_tmp/test.zip"); NewBatchJob job = new NewBatchJob(BATCHJOBID, testZip.getAbsolutePath(), "finished", 29, mockedProperties, mockedStages, null); job.setBatchProperties(mockedProperties); job.setTenantId(tenantId); ResourceEntry entry = new ResourceEntry(); entry.setResourceName(testZip.getAbsolutePath()); entry.setResourceFormat(FileFormat.ZIP_FILE.getCode()); job.addResourceEntry(entry); WorkNote workNote = Mockito.mock(WorkNote.class); Mockito.when(workNote.getBatchJobId()).thenReturn(BATCHJOBID); Exchange exchange = new DefaultExchange(new DefaultCamelContext()); exchange.getIn().setBody(workNote); Mockito.when(mockedBatchJobDAO.findBatchJobById(Matchers.eq(BATCHJOBID))).thenReturn(job); controlFilePreProcessor.setBatchJobDAO(mockedBatchJobDAO); controlFilePreProcessor.setTenantDA(mockedTenantDA); controlFilePreProcessor.process(exchange); Assert.assertEquals(2, job.getResourceEntries().size()); Assert.assertEquals(29, job.getTotalFiles()); }
### Question: StudentToStudentAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(STUDENT_ASSOCIATIONS, entityType, ids)) { return Collections.emptySet(); } Set<String> otherStudentIds = new HashSet<String>(); Set<String> toValidateIds = new HashSet<String>(ids); Entity self = SecurityUtil.getSLIPrincipal().getEntity(); List<Entity> associations = self.getEmbeddedData().get(entityType); for(Entity assoc : associations) { if (ids.contains(assoc.getEntityId())) { toValidateIds.remove(assoc.getEntityId()); } } if (toValidateIds.isEmpty()) { return ids; } NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, toValidateIds)); Map<String, Set<String>> studentIdsToAssoc = new HashMap<String, Set<String>>(); for(Entity association : getRepo().findAll(entityType, query)) { Map<String, Object>body = association.getBody(); if (!isFieldExpired(body, ParameterConstants.END_DATE, false)) { String studentId = (String) body.get(ParameterConstants.STUDENT_ID); otherStudentIds.add(studentId); if(!studentIdsToAssoc.containsKey(studentId)) { studentIdsToAssoc.put(studentId, new HashSet<String>()); } studentIdsToAssoc.get(studentId).add(association.getEntityId()); } else { return Collections.emptySet(); } } Set<String> validStudentIds = studentValidator.validate(EntityNames.STUDENT, otherStudentIds); toValidateIds.removeAll(getValidIds(validStudentIds, studentIdsToAssoc)); Set<String> validIds = new HashSet<String>(ids); validIds.removeAll(toValidateIds); return validIds; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testPositiveValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(assoc1Current.getEntityId(), assoc1Past.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_COHORT_ASSOCIATION, idsToValidate).containsAll(idsToValidate)); } @Test public void testHeterogeneousValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(assoc1Current.getEntityId(), assoc2.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_COHORT_ASSOCIATION, idsToValidate).containsAll(idsToValidate)); }
### Question: TransitiveStudentToStudentSectionAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStudentOrParent() && EntityNames.STUDENT_SECTION_ASSOCIATION.equals(entityType) && isTransitive; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_COHORT_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.STUDENT_PROGRAM_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, false)); assertFalse(validator.canValidate(EntityNames.ASSESSMENT, true)); assertFalse(validator.canValidate(EntityNames.GRADEBOOK_ENTRY, true)); assertFalse(validator.canValidate(EntityNames.COHORT, true)); assertFalse(validator.canValidate(EntityNames.STAFF_COHORT_ASSOCIATION, false)); }
### Question: TransitiveStudentToStudentSectionAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STUDENT_SECTION_ASSOCIATION, entityType, ids)) { return Collections.emptySet(); } Set<String> otherStudentIds = new HashSet<String>(); Map<String, Set<String>> studentIdToSSA = new HashMap<String, Set<String>>(); NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); for(Entity ssa : getRepo().findAll(EntityNames.STUDENT_SECTION_ASSOCIATION, query)) { Map<String, Object> body = ssa.getBody(); if (getDirectStudentIds().contains(body.get(ParameterConstants.STUDENT_ID))) { continue; } if (!isFieldExpired(body, ParameterConstants.END_DATE, false)) { String studentId = (String) ssa.getBody().get(ParameterConstants.STUDENT_ID); otherStudentIds.add(studentId); if(!studentIdToSSA.containsKey(studentId)) { studentIdToSSA.put(studentId, new HashSet<String>()); } studentIdToSSA.get(studentId).add(ssa.getEntityId()); } else { return Collections.emptySet(); } } Set<String> result; if(otherStudentIds.isEmpty()) { result = ids; } else { result = getValidIds(studentValidator.validate(EntityNames.STUDENT, otherStudentIds), studentIdToSSA); } return result; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testPositiveValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(assoc1Current.getEntityId(), assoc1Past.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_SECTION_ASSOCIATION, idsToValidate).containsAll(idsToValidate)); } @Test public void testHeterogeneousValidate() { Set<String> idsToValidate = new HashSet<String>(Arrays.asList(assoc1Current.getEntityId(), assoc2.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_SECTION_ASSOCIATION, idsToValidate).containsAll(idsToValidate)); }
### Question: TeacherToSectionValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTeacher() && EntityNames.SECTION.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.SECTION, false)); assertTrue(validator.canValidate(EntityNames.SECTION, true)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); }
### Question: StaffToStaffProgramAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STAFF_PROGRAM_ASSOCIATION.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STAFF_PROGRAM_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.STAFF_PROGRAM_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, false)); }
### Question: StaffToTeacherSchoolAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStaff() && EntityNames.TEACHER_SCHOOL_ASSOCIATION.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateStaffToTeacherSchoolAssociation() throws Exception { assertTrue(validator.canValidate(EntityNames.TEACHER_SCHOOL_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.TEACHER_SCHOOL_ASSOCIATION, true)); } @Test public void testDeniedStaffToOtherEntities() throws Exception { assertFalse(validator.canValidate(EntityNames.STUDENT, true)); assertFalse(validator.canValidate(EntityNames.STUDENT, false)); assertFalse(validator.canValidate(EntityNames.TEACHER, true)); assertFalse(validator.canValidate(EntityNames.TEACHER, false)); }
### Question: GenericToCohortValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return !isStudentOrParent() && !isTransitive && EntityNames.COHORT.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.COHORT, false)); assertFalse(validator.canValidate(EntityNames.COHORT, true)); assertFalse(validator.canValidate(EntityNames.COMPETENCY_LEVEL_DESCRIPTOR, false)); assertFalse(validator.canValidate(EntityNames.STAFF_COHORT_ASSOCIATION, true)); }
### Question: StaffToGlobalSectionValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.SECTION.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { setContext(seaStaff, Arrays.asList(SecureRoleRightAccessImpl.SEA_ADMINISTRATOR)); assertTrue(validator.canValidate(EntityNames.SECTION, true)); assertTrue(validator.canValidate(EntityNames.SECTION, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); } @Test public void testCanNotValidate() { setContext(educator2, Arrays.asList(SecureRoleRightAccessImpl.EDUCATOR)); SecurityUtil.setUserContext(SecurityUtil.UserContext.TEACHER_CONTEXT); assertFalse(validator.canValidate(EntityNames.SECTION, true)); assertFalse(validator.canValidate(EntityNames.SECTION, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); }
### Question: StaffToGlobalSectionValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.SECTION, entityType, ids)) { return Collections.EMPTY_SET; } Set<String> edOrgLineage = getEdorgDescendents(getDirectEdorgs()); NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids, false)); query.addCriteria(new NeutralCriteria(ParameterConstants.SCHOOL_ID, NeutralCriteria.CRITERIA_IN, edOrgLineage)); Set<String> validSections = new HashSet<String>(); if (ids.size() != getRepo().count(entityType, query)) { Iterable<String> sections = getRepo().findAllIds(entityType, query); validSections = Sets.newHashSet(sections); } else { validSections = ids; } return validSections; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testSeaAdministratorCanSeeSectionAtSchool() { setContext(seaStaff, Arrays.asList(SecureRoleRightAccessImpl.SEA_ADMINISTRATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section1.getEntityId()); sectionIds.add(section2.getEntityId()); assertTrue(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); } @Test public void testLeaAdministratorCanSeeSectionAtSchool() { setContext(lea1Staff, Arrays.asList(SecureRoleRightAccessImpl.LEA_ADMINISTRATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section1.getEntityId()); assertTrue(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); } @Test public void testLeaAdministratorCanNotSeeSectionAtSchool() { setContext(lea2Staff, Arrays.asList(SecureRoleRightAccessImpl.LEA_ADMINISTRATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section1.getEntityId()); assertFalse(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); } @Test public void testSchoolAdministratorCanSeeSectionAtSchool() { setContext(school1Staff, Arrays.asList(SecureRoleRightAccessImpl.IT_ADMINISTRATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section1.getEntityId()); assertTrue(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); } @Test public void testSchoolAdministratorCanNotSeeSectionAtSchool() { setContext(school2Staff, Arrays.asList(SecureRoleRightAccessImpl.IT_ADMINISTRATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section1.getEntityId()); assertFalse(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); } @Test public void testEducatorCanSeeSectionAtSchool() { setContext(educator1, Arrays.asList(SecureRoleRightAccessImpl.EDUCATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section1.getEntityId()); assertTrue(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); } @Test public void testEducatorCanNotSeeSectionAtSchool() { setContext(educator2, Arrays.asList(SecureRoleRightAccessImpl.EDUCATOR)); Set<String> sectionIds = new HashSet<String>(); sectionIds.add(section2.getEntityId()); assertTrue(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); sectionIds.add(section1.getEntityId()); assertFalse(validator.validate(EntityNames.SECTION, sectionIds).equals(sectionIds)); }
### Question: TeacherToTeacherSchoolAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.TEACHER_SCHOOL_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery nq = new NeutralQuery(new NeutralCriteria(ParameterConstants.TEACHER_ID, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil.getSLIPrincipal().getEntity().getEntityId())); Iterable<String> it = this.repo.findAllIds(EntityNames.TEACHER_SCHOOL_ASSOCIATION, nq); Set<String> fin = Sets.newHashSet(it); fin.retainAll(ids); return fin; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testValidateWrongType() { val.validate(EntityNames.ASSESSMENT, new HashSet<String>(Arrays.asList("Jomolungma"))); } @Test public void testSuccessOne() { Entity tsa = this.vth.generateTeacherSchool(USER_ID, "Myrran"); Set<String> ids = Collections.singleton(tsa.getEntityId()); Assert.assertTrue(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testSuccessMulti() { Set<String> ids = new HashSet<String>(); for (int i = 0; i < 100; i++) { ids.add(this.vth.generateTeacherSchool(USER_ID, "Myrran"+i).getEntityId()); } Assert.assertTrue(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testWrongId() { Set<String> ids = Collections.singleton("Hammerhands"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); ids = Collections.singleton("Nagas"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); ids = Collections.singleton("Phantom Warriors"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testHeterogenousList() { Set<String> ids = new HashSet<String>(Arrays.asList(this.vth.generateTeacherSchool(USER_ID, "Myrran").getEntityId(), "Pikemen", "Pegasi")); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); }
### Question: StudentToSubStudentValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return SUB_STUDENT_ENTITIES.contains(entityType) && isStudentOrParent(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testCanValidate() { injector.setStudentContext(student1); assertTrue(validator.canValidate(EntityNames.ATTENDANCE, true)); assertTrue(validator.canValidate(EntityNames.ATTENDANCE, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_ASSESSMENT, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_ASSESSMENT, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_GRADEBOOK_ENTRY, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_GRADEBOOK_ENTRY, false)); assertTrue(validator.canValidate(EntityNames.GRADE, true)); assertTrue(validator.canValidate(EntityNames.GRADE, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_ACADEMIC_RECORD, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_ACADEMIC_RECORD, false)); assertTrue(validator.canValidate(EntityNames.REPORT_CARD, true)); assertTrue(validator.canValidate(EntityNames.REPORT_CARD, false)); assertTrue(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.STUDENT, false)); assertFalse(validator.canValidate(EntityNames.PARENT, true)); assertFalse(validator.canValidate(EntityNames.EDUCATION_ORGANIZATION, false)); assertFalse(validator.canValidate(EntityNames.STAFF, true)); assertFalse(validator.canValidate(EntityNames.DISCIPLINE_ACTION, false)); assertFalse(validator.canValidate(EntityNames.GRADUATION_PLAN, true)); assertFalse(validator.canValidate(EntityNames.PROGRAM, true)); }
### Question: StudentToSubStudentValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(SUB_STUDENT_ENTITIES, entityType, ids)) { return Collections.emptySet(); } Map<String, Set<String>> studentIds = new HashMap<String, Set<String>>(getIdsContainedInFieldOnEntities(entityType, new ArrayList<String>(ids), ParameterConstants.STUDENT_ID)); return getValidIds(getDirectStudentIds(), studentIds); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); }### Answer: @Test public void testValidateSingleEntity() { injector.setStudentContext(student1); Set<String> idsToValidate = new HashSet<String>(Arrays.asList(attendance1.getEntityId())); assertTrue(validator.validate(EntityNames.ATTENDANCE, idsToValidate).containsAll(idsToValidate)); idsToValidate = new HashSet<String>(Arrays.asList(studentAcademicRecord1.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_ACADEMIC_RECORD, idsToValidate).containsAll(idsToValidate)); injector.setStudentContext(student2); idsToValidate = new HashSet<String>(Arrays.asList(attendance2.getEntityId())); assertTrue(validator.validate(EntityNames.ATTENDANCE, idsToValidate).containsAll(idsToValidate)); idsToValidate = new HashSet<String>(Arrays.asList(studentAcademicRecord2.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_ACADEMIC_RECORD, idsToValidate).containsAll(idsToValidate)); } @Test public void testValidateNegativeHeterogeneousList() { injector.setStudentContext(student1); Set<String> idsToValidate = new HashSet<String>(Arrays.asList(attendance1.getEntityId(),attendance2.getEntityId())); assertFalse(validator.validate(EntityNames.ATTENDANCE, idsToValidate).containsAll(idsToValidate)); idsToValidate = new HashSet<String>(Arrays.asList(studentAcademicRecord1.getEntityId(), studentAcademicRecord2.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_ACADEMIC_RECORD, idsToValidate).containsAll(idsToValidate)); }
### Question: TeacherToStudentCompetencyValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTeacher() && EntityNames.STUDENT_COMPETENCY.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STUDENT_COMPETENCY, true)); assertTrue(validator.canValidate(EntityNames.STUDENT_COMPETENCY, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); }
### Question: TeacherToStudentCompetencyValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STUDENT_COMPETENCY, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); query.setIncludeFields(Arrays.asList(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID)); Iterable<Entity> comps = getRepo().findAll(EntityNames.STUDENT_COMPETENCY, query); Map<String, Set<String>> secAssocIds = new HashMap<String, Set<String>>(); for (Entity comp : comps) { String id = (String) comp.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); if (!secAssocIds.containsKey(id)) { secAssocIds.put(id, new HashSet<String>()); } secAssocIds.get(id).add(comp.getEntityId()); } Set<String> validSectionIds = sectionAssocValidator.validate(EntityNames.STUDENT_SECTION_ASSOCIATION, secAssocIds.keySet()); return getValidIds(validSectionIds, secAssocIds); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidComps() { Set<String> ids = new HashSet<String>(Arrays.asList(sComp1.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_COMPETENCY, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(sComp2.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_COMPETENCY, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(sComp1.getEntityId(), sComp2.getEntityId())); assertTrue(validator.validate(EntityNames.STUDENT_COMPETENCY, ids).equals(ids)); } @Test public void testInvalidComps() { Set<String> ids = new HashSet<String>(Arrays.asList(sComp3.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_COMPETENCY, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(sComp1.getEntityId(), sComp3.getEntityId())); assertFalse(validator.validate(EntityNames.STUDENT_COMPETENCY, ids).equals(ids)); }
### Question: TeacherToCourseTranscriptValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTeacher() && EntityNames.COURSE_TRANSCRIPT.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateAsTeacher() { setupCurrentUser(teacher1); Assert.assertTrue("Must be able to validate", validator.canValidate(EntityNames.COURSE_TRANSCRIPT, false)); Assert.assertTrue("Must be able to validate", validator.canValidate(EntityNames.COURSE_TRANSCRIPT, true)); Assert.assertFalse("Must not be able to validate", validator.canValidate(EntityNames.ADMIN_DELEGATION, false)); }
### Question: TeacherToCourseTranscriptValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.COURSE_TRANSCRIPT, entityType, ids)) { return Collections.emptySet(); } Map<String, Set<String>> studentAcademicRecordToCT = new HashMap<String, Set<String>>(); NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, new ArrayList<String>(ids))); Iterable<Entity> entities = getRepo().findAll(EntityNames.COURSE_TRANSCRIPT, query); for (Entity entity : entities) { Map<String, Object> body = entity.getBody(); if (body.get(ParameterConstants.STUDENT_ACADEMIC_RECORD_ID) instanceof String) { String id = (String) body.get(ParameterConstants.STUDENT_ACADEMIC_RECORD_ID); if (!studentAcademicRecordToCT.containsKey(id)) { studentAcademicRecordToCT.put(id, new HashSet<String>()); } studentAcademicRecordToCT.get(id).add(entity.getEntityId()); } else { LOG.warn("Possible Corrupt Data detected at "+entityType+"/"+entity.getEntityId()); } } if (studentAcademicRecordToCT.isEmpty()) { return Collections.EMPTY_SET; } Set<String> sarIds = validator.validate(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecordToCT.keySet()); return getValidIds(sarIds, studentAcademicRecordToCT); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidAssociations() { setupCurrentUser(teacher1); Assert.assertEquals(1, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(courseTranscript1.getEntityId()))).size()); } @Test public void testInvalidAssociations() { setupCurrentUser(teacher1); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(UUID.randomUUID().toString()))).size()); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>()).size()); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(courseTranscript2.getEntityId()))).size()); }
### Question: StaffToDisciplineIncidentValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStaff() && EntityNames.DISCIPLINE_INCIDENT.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); void setSubStudentValidator(StaffToSubStudentEntityValidator subStudentValidator); void setSchoolValidator(GenericToEdOrgValidator schoolValidator); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.DISCIPLINE_INCIDENT, true)); assertTrue(validator.canValidate(EntityNames.DISCIPLINE_INCIDENT, false)); assertFalse(validator.canValidate(EntityNames.SECTION, true)); assertFalse(validator.canValidate(EntityNames.SECTION, false)); }
### Question: TeacherToStaffCohortAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STAFF_COHORT_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery nq = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_ID, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil.getSLIPrincipal().getEntity().getEntityId())); nq.addCriteria(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); Iterable<String> result = getRepo().findAllIds(EntityNames.STAFF_COHORT_ASSOCIATION, nq); return Sets.newHashSet(result); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testValidateWrongType() { val.validate(EntityNames.ASSESSMENT, new HashSet<String>(Arrays.asList("Jomolungma"))); } @Test public void testCanAccessAll() { List<String> ids = Arrays.asList("Just Cause", "Armaggedon", "Awareness"); Set<String> sca = new HashSet<String>(); for (String id : ids) { sca.add(this.vth.generateStaffCohort(USER_ID, id, false, true).getEntityId()); } Assert.assertTrue(val.validate(EntityNames.STAFF_COHORT_ASSOCIATION, sca).equals(sca)); } @Test public void testCannotAccessAll() { List<String> ids = Arrays.asList("Just Cause", "Armaggedon", "Awareness"); Set<String> sca = new HashSet<String>(); for (String id : ids) { sca.add(this.vth.generateStaffCohort("Sky Drake", id, false, true).getEntityId()); } Assert.assertFalse(val.validate(EntityNames.STAFF_COHORT_ASSOCIATION, sca).equals(sca)); for (String id : sca) { Set<String> single = Collections.singleton(id); Assert.assertFalse(val.validate(EntityNames.STAFF_COHORT_ASSOCIATION, single).equals(single)); } } @Test public void testHeterogeneousList() { List<String> ids = Arrays.asList("Just Cause", "Armaggedon", "Awareness", "Chaos Mastery", "Life Mastery", "Death and Decay", "Node Mastery", "Artificer", "Warlord", "Conjurer"); Set<String> sca = new HashSet<String>(); List<String> successes = new ArrayList<String>(); for (String id : ids) { if (Math.random() > 0.33) { sca.add(this.vth.generateStaffCohort("Sky Drake", id, false, true).getEntityId()); } else if (Math.random() > 0.5) { String id2 = this.vth.generateStaffCohort(USER_ID, id, false, true).getEntityId(); sca.add(id2); successes.add(id2); } else { sca.add("Earth Elemental"); } } Assert.assertFalse(val.validate(EntityNames.STAFF_COHORT_ASSOCIATION, sca).equals(sca)); for (String id : sca) { Set<String> single = Collections.singleton(id); if (successes.contains(id)) { Assert.assertTrue(val.validate(EntityNames.STAFF_COHORT_ASSOCIATION, single).equals(single)); } else { Assert.assertFalse(val.validate(EntityNames.STAFF_COHORT_ASSOCIATION, single).equals(single)); } } }
### Question: TeacherToSubStudentEntityValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean through) { return isTeacher() && isSubEntityOfStudent(entityType); } @Override boolean canValidate(String entityType, boolean through); @SuppressWarnings("unchecked") @Override Set<String> validate(String entityType, Set<String> ids); void setRepo(PagingRepositoryDelegate<Entity> repo); void setTeacherToStudentValidator(TeacherToStudentValidator teacherToStudentValidator); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateTeacherToAttendance() throws Exception { assertTrue(validator.canValidate(EntityNames.ATTENDANCE, false)); } @Test public void testCanValidateTeacherToDisciplineAction() throws Exception { assertTrue(validator.canValidate(EntityNames.DISCIPLINE_ACTION, false)); } @Test public void testCanValidateTeacherToStudentAcademicRecord() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_ACADEMIC_RECORD, false)); } @Test public void testCanValidateTeacherToStudentAssessment() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_ASSESSMENT, false)); } @Test public void testCanValidateTeacherToStudentDisciplineIncident() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_DISCIPLINE_INCIDENT_ASSOCIATION, false)); } @Test public void testCanValidateTeacherToStudentGradebookEntry() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_GRADEBOOK_ENTRY, false)); } @Test public void testCanValidateTeacherToStudentSchoolAssociation() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_SCHOOL_ASSOCIATION, false)); } @Test public void testCanValidateTeacherToStudentSectionAssociation() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT_SECTION_ASSOCIATION, false)); } @Test public void testCanNotValidateOtherEntities() throws Exception { assertFalse(validator.canValidate(EntityNames.STUDENT, false)); }
### Question: StaffToStudentValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STUDENT.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> getValid(String entityType, Set<String> studentIds); @Override Set<String> validate(String entityType, Set<String> studentIds); void setProgramValidator(GenericToProgramValidator programValidator); void setCohortValidator(GenericToCohortValidator cohortValidator); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateStaffToStudents() throws Exception { assertTrue(validator.canValidate(EntityNames.STUDENT, false)); } @Test public void testCanNotValidateOtherEntities() throws Exception { assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); }
### Question: StaffToStaffCohortAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.STAFF_COHORT_ASSOCIATION.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.STAFF_COHORT_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.STAFF_COHORT_ASSOCIATION, true)); assertFalse(validator.canValidate(EntityNames.COHORT, true)); assertFalse(validator.canValidate(EntityNames.COHORT, false)); }
### Question: StaffToCourseTranscriptValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return EntityNames.COURSE_TRANSCRIPT.equals(entityType) && isStaff(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateAsStaff() { setupCurrentUser(staff1); Assert.assertTrue("Must be able to validate", validator.canValidate(EntityNames.COURSE_TRANSCRIPT, false)); Assert.assertTrue("Must be able to validate", validator.canValidate(EntityNames.COURSE_TRANSCRIPT, true)); Assert.assertFalse("Must not be able to validate", validator.canValidate(EntityNames.ADMIN_DELEGATION, false)); }
### Question: StaffToCourseTranscriptValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.COURSE_TRANSCRIPT, entityType, ids)) { return Collections.emptySet(); } LOG.info("Validating {}'s access to courseTranscripts: [{}]", SecurityUtil.getSLIPrincipal().getName(), ids); NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, new ArrayList<String>(ids))); Iterable<Entity> entities = getRepo().findAll(EntityNames.COURSE_TRANSCRIPT, query); Map<String, Set<String>> studentAcademicRecords = new HashMap<String, Set<String>>(); for (Entity entity : entities) { Map<String, Object> body = entity.getBody(); if (body.get(ParameterConstants.STUDENT_ACADEMIC_RECORD_ID) instanceof String) { String key = (String) body.get(ParameterConstants.STUDENT_ACADEMIC_RECORD_ID); if(!studentAcademicRecords.containsKey(key)) { studentAcademicRecords.put(key, new HashSet<String>()); } studentAcademicRecords.get(key).add(entity.getEntityId()); } else { LOG.warn("Possible Corrupt Data detected at "+entityType+"/"+entity.getEntityId()); } } if (studentAcademicRecords.isEmpty()) { return Collections.EMPTY_SET; } Set<String> validStudentAcademicRecords = validator.validate(EntityNames.STUDENT_ACADEMIC_RECORD, studentAcademicRecords.keySet()); return getValidIds(validStudentAcademicRecords, studentAcademicRecords); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidAssociationsForStaff1() { setupCurrentUser(staff1); Assert.assertEquals(1, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(courseTranscript1.getEntityId()))).size()); } @Test public void testValidAssociationsForStaff2() { setupCurrentUser(staff2); Assert.assertEquals(1, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(courseTranscript2.getEntityId()))).size()); } @Test public void testInValidAssociationsForStaff1() { setupCurrentUser(staff1); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(courseTranscript2.getEntityId()))).size()); } @Test public void testInValidAssociationsForStaff2() { setupCurrentUser(staff2); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(courseTranscript1.getEntityId()))).size()); } @Test public void testInvalidAssociations() { setupCurrentUser(staff2); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>(Arrays.asList(UUID.randomUUID().toString()))).size()); Assert.assertEquals(0, validator.validate(EntityNames.COURSE_TRANSCRIPT, new HashSet<String>()).size()); }
### Question: TeacherToCohortValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTransitive && EntityNames.COHORT.equals(entityType) && isTeacher(); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertFalse(val.canValidate(EntityNames.COHORT, false)); assertTrue(val.canValidate(EntityNames.COHORT, true)); assertFalse(val.canValidate(EntityNames.SECTION, true)); assertFalse(val.canValidate(EntityNames.SECTION, false)); }
### Question: TeacherToCohortValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { Set<String> validIds = new HashSet<String>(); if (!areParametersValid(EntityNames.COHORT, entityType, ids)) { return validIds; } NeutralQuery nq = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_ID, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil .getSLIPrincipal().getEntity().getEntityId())); nq.addCriteria(new NeutralCriteria(ParameterConstants.COHORT_ID, NeutralCriteria.CRITERIA_IN, ids)); Iterable<Entity> entities = getRepo().findAll(EntityNames.STAFF_COHORT_ASSOCIATION, nq); for (Entity entity : entities) { validIds.add((String) entity.getBody().get(ParameterConstants.COHORT_ID)); } validIds.retainAll(ids); return validIds; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testValidateWrongType() { val.validate(EntityNames.ASSESSMENT, new HashSet<String>(Arrays.asList("Jomolungma"))); } @Test public void testCanAccessAll() { List<String> descs = Arrays.asList("Just Cause", "Armaggedon", "Awareness"); Set<String> cohortIds = new HashSet<String>(); for (String desc : descs) { cohortIds.add(this.generateCohortAndAssociate(USER_ID, desc)); } Assert.assertTrue(!val.validate(EntityNames.COHORT, cohortIds).isEmpty()); } @Test public void testCannotAccessAll() { List<String> descs = Arrays.asList("Just Cause", "Armaggedon", "Awareness"); Set<String> cohortIds = new HashSet<String>(); for (String desc : descs) { cohortIds.add(this.generateCohort(USER_ID, desc)); } Assert.assertFalse(val.validate(EntityNames.COHORT, cohortIds).size() == cohortIds.size()); for (String id : cohortIds) { Assert.assertFalse(val.validate(EntityNames.COHORT, Collections.singleton(id)).size() == 1); } } @Test public void testHeterogeneousList() { List<String> descs = Arrays.asList("Just Cause", "Armageddon", "Awareness", "Chaos Mastery", "Life Mastery", "Death and Decay", "Node Mastery", "Artificer", "Warlord", "Conjurer"); Set<String> cohortIds = new HashSet<String>(); List<String> successes = new ArrayList<String>(); cohortIds.add(this.generateCohort(USER_ID, "Artifacts Home World")); String idPerm = this.generateCohortAndAssociate(USER_ID, "Large Home World"); cohortIds.add(idPerm); successes.add(idPerm); for (String desc : descs) { if(Math.random()>0.5) { cohortIds.add(this.generateCohort(USER_ID, desc)); } else { String id = this.generateCohortAndAssociate(USER_ID, desc); cohortIds.add(id); successes.add(id); } } Assert.assertFalse(val.validate(EntityNames.COHORT, cohortIds).containsAll(cohortIds)); for (String id : cohortIds) { if(successes.contains(id)) { Assert.assertEquals(val.validate(EntityNames.COHORT, Collections.singleton(id)).size(), 1); } else { Assert.assertFalse(!val.validate(EntityNames.COHORT, Collections.singleton(id)).isEmpty()); } } }
### Question: GenericToProgramValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return !isStudentOrParent() && EntityNames.PROGRAM.equals(entityType) && !isTransitive; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { setupCurrentUser(teacher1); Assert.assertTrue(validator.canValidate(EntityNames.PROGRAM, false)); Assert.assertFalse(validator.canValidate(EntityNames.PROGRAM, true)); injector.setStaffContext(); Assert.assertTrue(validator.canValidate(EntityNames.PROGRAM, false)); Assert.assertFalse(validator.canValidate(EntityNames.PROGRAM, true)); }
### Question: GenericToProgramValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.PROGRAM, entityType, ids)) { return new HashSet<String>(); } NeutralQuery nq = new NeutralQuery(new NeutralCriteria("body.staffId", "=", SecurityUtil.getSLIPrincipal().getEntity().getEntityId(), false)); if (SecurityUtil.getSLIPrincipal().isStudentAccessFlag()) { nq.addCriteria(new NeutralCriteria(ParameterConstants.STUDENT_RECORD_ACCESS, NeutralCriteria.OPERATOR_EQUAL, true)); } addEndDateToQuery(nq, false); Set<String> validIds = new HashSet<String>(); Iterable<Entity> assocs = getRepo().findAll(EntityNames.STAFF_PROGRAM_ASSOCIATION, nq); for (Entity assoc : assocs) { validIds.add((String) assoc.getBody().get("programId")); } validIds.retainAll(ids); return validIds; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidAccessTeacher1() { setupCurrentUser(teacher1); Assert.assertTrue(validator.validate(EntityNames.PROGRAM, new HashSet<String>(Arrays.asList(program1.getEntityId()))).size() == 1); } @Test public void testValidAccessTeacher2() { setupCurrentUser(teacher2); Assert.assertTrue(validator.validate(EntityNames.PROGRAM, new HashSet<String>(Arrays.asList(program2.getEntityId()))).size() == 1); } @Test public void testInvalidAccessTeacher1() { setupCurrentUser(teacher1); Set<String> program = new HashSet<String>(Arrays.asList(program2.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.PROGRAM, program).equals(program)); program = new HashSet<String>(Arrays.asList(program3.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.PROGRAM, program).equals(program)); program = new HashSet<String>(Arrays.asList(program4.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.PROGRAM, program).equals(program)); } @Test public void testInvalidAccessTeacher2() { setupCurrentUser(teacher2); Set<String> program = new HashSet<String>(Arrays.asList(program1.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.PROGRAM, program).equals(program)); program = new HashSet<String>(Arrays.asList(program3.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.PROGRAM, program).equals(program)); program = new HashSet<String>(Arrays.asList(program4.getEntityId())); Assert.assertFalse(validator.validate(EntityNames.PROGRAM, program).equals(program)); }
### Question: StaffToCohortValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTransitive && isStaff() && EntityNames.COHORT.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertFalse(validator.canValidate(EntityNames.COHORT, false)); assertTrue(validator.canValidate(EntityNames.COHORT, true)); assertFalse(validator.canValidate(EntityNames.SECTION, true)); assertFalse(validator.canValidate(EntityNames.SECTION, false)); }
### Question: GenericToEdOrgValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { if (EntityNames.SCHOOL.equals(entityType) \|\| EntityNames.EDUCATION_ORGANIZATION.equals(entityType)) { if (isStudentOrParent()) { return !isTransitive; } return true; } return false; } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.SCHOOL, false)); assertTrue(validator.canValidate(EntityNames.SCHOOL, true)); assertTrue(validator.canValidate(EntityNames.EDUCATION_ORGANIZATION, false)); assertTrue(validator.canValidate(EntityNames.EDUCATION_ORGANIZATION, true)); } @Test public void testCanNotValidate() { assertFalse(validator.canValidate(EntityNames.ATTENDANCE, true)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); assertFalse(validator.canValidate(EntityNames.SECTION, true)); assertFalse(validator.canValidate(EntityNames.SECTION, false)); }
### Question: DidSchemaParser implements ResourceLoaderAware { public Map<String, DidEntityConfig> getEntityConfigs() { return entityConfigs; } String getExtensionXsdLocation(); void setExtensionXsdLocation(String entensionXsdLocation); String getExtensionXsdParentLocation(); void setExtensionXsdParentLocation(String extensionXsdParentLocation); String getXsdParentLocation(); void setXsdParentLocation(String xsdParentLocation); String getXsdLocation(); void setXsdLocation(String xsdLocation); Map<String, List<DidNaturalKey>> getNaturalKeys(); void setNaturalKeys(Map<String, List<DidNaturalKey>> naturalKeys); @Override void setResourceLoader(ResourceLoader resourceLoader); @PostConstruct void setup(); Map<String, DidRefConfig> getRefConfigs(); Map<String, DidEntityConfig> getEntityConfigs(); Map<String, List<DidNaturalKey>> extractNaturalKeys(); }### Answer: @Test public void shouldExtractEntityConfigs() { Map<String, DidEntityConfig> entityConfigs = didSchemaParser.getEntityConfigs(); Assert.assertEquals("Should extract 5 entity config for the 5 complexType containing a sectionReference (SLC-GradebookEntry)", 5, entityConfigs.size()); Assert.assertTrue(entityConfigs.containsKey(GRADEBOOKENTRY_TYPE)); DidEntityConfig gbeConfig = entityConfigs.get(GRADEBOOKENTRY_TYPE); Assert.assertNotNull(gbeConfig); Assert.assertNotNull(gbeConfig.getReferenceSources()); List<DidRefSource> refSources = gbeConfig.getReferenceSources(); Assert.assertEquals("entity config should contain a single DidRefSource (section)", 1, refSources.size()); DidRefSource refSource = refSources.get(0); Assert.assertNotNull(refSource); Assert.assertEquals(SECTION_TYPE, refSource.getEntityType()); Assert.assertEquals("body.SectionReference", refSource.getSourceRefPath()); }
### Question: TeacherToGradeValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isTeacher() && EntityNames.GRADE.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidate() { assertTrue(validator.canValidate(EntityNames.GRADE, true)); assertTrue(validator.canValidate(EntityNames.GRADE, false)); assertFalse(validator.canValidate(EntityNames.ATTENDANCE, false)); }
### Question: TeacherToGradeValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.GRADE, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); query.setIncludeFields(Arrays.asList(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID)); Iterable<Entity> grades = getRepo().findAll(EntityNames.GRADE, query); Map<String, Set<String>> secAssocIdsToGrade = new HashMap<String, Set<String>>(); for(Entity grade : grades) { String id = (String) grade.getBody().get(ParameterConstants.STUDENT_SECTION_ASSOCIATION_ID); if (!secAssocIdsToGrade.containsKey(id)) { secAssocIdsToGrade.put(id, new HashSet<String>()); } secAssocIdsToGrade.get(id).add(grade.getEntityId()); } Set<String> validSecAssocIds = sectionAssocValidator.validate(EntityNames.STUDENT_SECTION_ASSOCIATION, secAssocIdsToGrade.keySet()); return getValidIds(validSecAssocIds, secAssocIdsToGrade); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testValidGrades() { Set<String> ids = new HashSet<String>(Arrays.asList(grade1.getEntityId())); assertTrue(validator.validate(EntityNames.GRADE, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(grade2.getEntityId())); assertTrue(validator.validate(EntityNames.GRADE, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(grade1.getEntityId(), grade2.getEntityId())); assertTrue(validator.validate(EntityNames.GRADE, ids).equals(ids)); } @Test public void testInvalidGrades() { Set<String> ids = new HashSet<String>(Arrays.asList(grade3.getEntityId())); assertFalse(validator.validate(EntityNames.GRADE, ids).equals(ids)); ids = new HashSet<String>(Arrays.asList(grade1.getEntityId(), grade3.getEntityId())); assertFalse(validator.validate(EntityNames.GRADE, ids).equals(ids)); }
### Question: StaffToTeacherSectionAssociationValidator extends AbstractContextValidator { @Override public boolean canValidate(String entityType, boolean isTransitive) { return isStaff() && EntityNames.TEACHER_SECTION_ASSOCIATION.equals(entityType); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testCanValidateStaffToTeacherSectionAssociation() throws Exception { setContext(seaStaff, Arrays.asList(SecureRoleRightAccessImpl.SEA_ADMINISTRATOR)); assertTrue(validator.canValidate(EntityNames.TEACHER_SECTION_ASSOCIATION, false)); assertTrue(validator.canValidate(EntityNames.TEACHER_SECTION_ASSOCIATION, true)); } @Test public void testDeniedStaffToOtherEntities() throws Exception { setContext(seaStaff, Arrays.asList(SecureRoleRightAccessImpl.SEA_ADMINISTRATOR)); assertFalse(validator.canValidate(EntityNames.STUDENT, true)); assertFalse(validator.canValidate(EntityNames.STUDENT, false)); assertFalse(validator.canValidate(EntityNames.TEACHER, true)); assertFalse(validator.canValidate(EntityNames.TEACHER, false)); } @Test public void testCanNotValidateAsNonStaffToTeacherSectionAssociation() throws Exception { setContext(educator, Arrays.asList(SecureRoleRightAccessImpl.EDUCATOR)); SecurityUtil.setUserContext(SecurityUtil.UserContext.TEACHER_CONTEXT); assertFalse(validator.canValidate(EntityNames.TEACHER_SECTION_ASSOCIATION, false)); assertFalse(validator.canValidate(EntityNames.TEACHER_SECTION_ASSOCIATION, true)); }
### Question: DidSchemaParser implements ResourceLoaderAware { public Map<String, List<DidNaturalKey>> getNaturalKeys() { return naturalKeys; } String getExtensionXsdLocation(); void setExtensionXsdLocation(String entensionXsdLocation); String getExtensionXsdParentLocation(); void setExtensionXsdParentLocation(String extensionXsdParentLocation); String getXsdParentLocation(); void setXsdParentLocation(String xsdParentLocation); String getXsdLocation(); void setXsdLocation(String xsdLocation); Map<String, List<DidNaturalKey>> getNaturalKeys(); void setNaturalKeys(Map<String, List<DidNaturalKey>> naturalKeys); @Override void setResourceLoader(ResourceLoader resourceLoader); @PostConstruct void setup(); Map<String, DidRefConfig> getRefConfigs(); Map<String, DidEntityConfig> getEntityConfigs(); Map<String, List<DidNaturalKey>> extractNaturalKeys(); }### Answer: @Test public void shouldextractNaturalKeys() { Map<String, List<DidNaturalKey>> naturalKeys = didSchemaParser.getNaturalKeys(); Assert.assertNotNull(naturalKeys); Assert.assertTrue(naturalKeys.containsKey("learningObjective")); List<DidNaturalKey> keys = naturalKeys.get("learningObjective"); Assert.assertNotNull(keys); Assert.assertEquals(3, keys.size()); Assert.assertEquals("Objective", keys.get(0).getNaturalKeyName()); Assert.assertFalse(keys.get(0).isOptional); Assert.assertTrue(naturalKeys.containsKey("localEducationAgency")); keys = naturalKeys.get("localEducationAgency"); Assert.assertNotNull(keys); Assert.assertEquals(1, keys.size()); Assert.assertEquals("StateOrganizationId", keys.get(0).getNaturalKeyName()); Assert.assertFalse(keys.get(0).isOptional); Assert.assertTrue(naturalKeys.containsKey("studentCompetency")); keys = naturalKeys.get("studentCompetency"); Assert.assertNotNull(keys); Assert.assertEquals(4, keys.size()); Assert.assertEquals("CompetencyLevel.CodeValue", keys.get(1).getNaturalKeyName()); Assert.assertFalse(keys.get(1).isOptional); Assert.assertEquals("LearningObjectiveReference", keys.get(3).getNaturalKeyName()); Assert.assertTrue(keys.get(3).isOptional); Assert.assertTrue(naturalKeys.containsKey("attendance")); keys = naturalKeys.get("attendance"); Assert.assertNotNull(keys); Assert.assertEquals(4, keys.size()); Assert.assertEquals("StateOrganizationId", keys.get(1).getNaturalKeyName()); Assert.assertFalse(keys.get(1).isOptional); Assert.assertTrue(naturalKeys.containsKey("reportCard")); keys = naturalKeys.get("reportCard"); Assert.assertNotNull(keys); Assert.assertEquals(2, keys.size()); Assert.assertEquals("GradingPeriodReference", keys.get(1).getNaturalKeyName()); Assert.assertFalse(keys.get(1).isOptional); Assert.assertTrue(naturalKeys.containsKey("program")); keys = naturalKeys.get("program"); Assert.assertNotNull(keys); Assert.assertEquals(1, keys.size()); Assert.assertEquals("ProgramId", keys.get(0).getNaturalKeyName()); Assert.assertFalse(keys.get(0).isOptional); }
### Question: StaffToTeacherSectionAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.TEACHER_SECTION_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery query = new NeutralQuery(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, new ArrayList<String>(ids))); Iterable<Entity> teacherSectionAssociations = getRepo().findAll(entityType, query); Map<String, Set<String>> sections = new HashMap<String, Set<String>>(); if (teacherSectionAssociations != null) { for (Entity teacherSectionAssociation : teacherSectionAssociations) { Map<String, Object> body = teacherSectionAssociation.getBody(); String section = (String) body.get(ParameterConstants.SECTION_ID); if (!sections.containsKey(section)) { sections.put(section, new HashSet<String>()); } sections.get(section).add(teacherSectionAssociation.getEntityId()); } } if (sections.isEmpty()) { return Collections.EMPTY_SET; } Set<String> validSections = validator.validate(EntityNames.SECTION, sections.keySet()); return getValidIds(validSections, sections); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test public void testNullTeacherSectionAssociation() throws Exception { assertTrue(validator.validate(EntityNames.TEACHER_SECTION_ASSOCIATION, null).isEmpty()); } @Test public void testEmptyTeacherSectionAssociation() throws Exception { Set<String> teacherSectionAssociations = new HashSet<String>(); assertTrue(validator.validate(EntityNames.TEACHER_SECTION_ASSOCIATION, teacherSectionAssociations).isEmpty()); } @Test public void testSeaAdministratorCanGetAccessToTeacherSectionAssociation() throws Exception { setContext(seaStaff, Arrays.asList(SecureRoleRightAccessImpl.SEA_ADMINISTRATOR)); Set<String> teacherSectionAssociations = new HashSet<String>(); teacherSectionAssociations.add(teacherSectionAssociation.getEntityId()); assertTrue(validator.validate(EntityNames.TEACHER_SECTION_ASSOCIATION, teacherSectionAssociations).equals(teacherSectionAssociations)); } @Test public void testLeaAdministratorCanGetAccessToTeacherSectionAssociation() throws Exception { setContext(leaStaff, Arrays.asList(SecureRoleRightAccessImpl.LEA_ADMINISTRATOR)); Set<String> teacherSectionAssociations = new HashSet<String>(); teacherSectionAssociations.add(teacherSectionAssociation.getEntityId()); assertTrue(validator.validate(EntityNames.TEACHER_SECTION_ASSOCIATION, teacherSectionAssociations).equals(teacherSectionAssociations)); } @Test public void testSchoolAdministratorCanGetAccessToTeacherSectionAssociation() throws Exception { setContext(schoolStaff, Arrays.asList(SecureRoleRightAccessImpl.IT_ADMINISTRATOR)); Set<String> teacherSectionAssociations = new HashSet<String>(); teacherSectionAssociations.add(teacherSectionAssociation.getEntityId()); assertTrue(validator.validate(EntityNames.TEACHER_SECTION_ASSOCIATION, teacherSectionAssociations).equals(teacherSectionAssociations)); }
### Question: TeacherToStaffProgramAssociationValidator extends AbstractContextValidator { @Override public Set<String> validate(String entityType, Set<String> ids) throws IllegalStateException { if (!areParametersValid(EntityNames.STAFF_PROGRAM_ASSOCIATION, entityType, ids)) { return Collections.EMPTY_SET; } NeutralQuery nq = new NeutralQuery(new NeutralCriteria(ParameterConstants.STAFF_ID, NeutralCriteria.OPERATOR_EQUAL, SecurityUtil.getSLIPrincipal().getEntity().getEntityId())); nq.addCriteria(new NeutralCriteria(ParameterConstants.ID, NeutralCriteria.CRITERIA_IN, ids)); Iterable<String> validIds= getRepo().findAllIds(EntityNames.STAFF_PROGRAM_ASSOCIATION, nq); return Sets.newHashSet(validIds); } @Override boolean canValidate(String entityType, boolean isTransitive); @Override Set<String> validate(String entityType, Set<String> ids); @Override SecurityUtil.UserContext getContext(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testValidateWrongType() { val.validate(EntityNames.ASSESSMENT, new HashSet<String>(Arrays.asList("Jomolungma"))); } @Test public void testSuccessOne() { Entity tsa = this.vth.generateStaffProgram(USER_ID, PROGRAM_ID, false, true); Set<String> ids = Collections.singleton(tsa.getEntityId()); Assert.assertTrue(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testSuccessMulti() { Set<String> ids = new HashSet<String>(); for (int i = 0; i < 100; i++) { ids.add(this.vth.generateStaffProgram(USER_ID, PROGRAM_ID, false, true).getEntityId()); } Assert.assertTrue(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testWrongId() { Set<String> ids = Collections.singleton("Hammerhands"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); ids = Collections.singleton("Nagas"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); ids = Collections.singleton("Phantom Warriors"); Assert.assertFalse(val.validate(CORRECT_ENTITY_TYPE, ids).equals(ids)); } @Test public void testHeterogenousList() { Set<String> ids = new HashSet<String>(Arrays.asList(this.vth.generateStaffProgram(USER_ID, PROGRAM_ID, false, true).getEntityId(), this.vth.generateStaffProgram("Ssss'ra", "Arcanus", false, true).getEntityId(), this.vth.generateStaffProgram("Kali", "Arcanus", false, true).getEntityId())); Assert.assertFalse(val.validate( CORRECT_ENTITY_TYPE, ids).equals(ids)); }
### Question: SecurityEventBuilder { public SecurityEvent createSecurityEvent(String loggingClass, URI requestUri, String slMessage, boolean defaultTargetToUserEdOrg) { return createSecurityEvent( loggingClass, requestUri, slMessage, null, null,null, null, defaultTargetToUserEdOrg); } SecurityEventBuilder(); SecurityEvent createSecurityEvent(String loggingClass, URI requestUri, String slMessage, boolean defaultTargetToUserEdOrg); SecurityEvent createSecurityEvent(String loggingClass, URI requestUri, String slMessage, Entity explicitRealmEntity, String entityType, String[] entityIds); SecurityEvent createSecurityEvent(String loggingClass, URI requestUri, String slMessage, Entity explicitRealmEntity, String entityType, Set<Entity> entities); SecurityEvent createSecurityEvent(String loggingClass, URI explicitUri, String slMessage, SLIPrincipal explicitPrincipal, String clientId, Entity explicitRealmEntity, Set<String> targetEdOrgs, boolean defaultTargetToUserEdOrg); CallingApplicationInfoProvider getCallingApplicationInfoProvider(); void setCallingApplicationInfoProvider(CallingApplicationInfoProvider callingApplicationInfoProvider); }### Answer: @Test public void testCreateSecurityEventUsingDefaultTargetToUserEdOrg() { SecurityEvent se = builder.createSecurityEvent(this.getClass().getName(), URI.create(ONE_PART_URI), LOG_MESSAGE, true); Assert.assertTrue(se.getActionUri().equals(ONE_PART_URI)); Assert.assertTrue(se.getLogMessage().equals(LOG_MESSAGE)); Assert.assertTrue(se.getUserEdOrg().equals(REALM_EDORG_STATEID)); Assert.assertTrue(se.getTargetEdOrgList().contains(se.getUserEdOrg())); } @Test public void testCreateSecurityEventFromEntityIds() { prepareTargetEdOrgMocks(); String[] entityIds = {SECTION_ENTITY_ID, SECTION_ENTITY2_ID}; SecurityEvent se = builder.createSecurityEvent(this.getClass().getName(), URI.create(ONE_PART_URI), LOG_MESSAGE, null, EntityNames.SECTION, entityIds); Assert.assertTrue(se.getActionUri().equals(ONE_PART_URI)); Assert.assertTrue(se.getLogMessage().equals(LOG_MESSAGE)); Assert.assertTrue(se.getUserEdOrg().equals(REALM_EDORG_STATEID)); Assert.assertTrue(containsTheSame(se.getTargetEdOrgList(), Arrays.asList(EDORG_STATEID, EDORG2_STATEID))); } @Test public void testCreateSecurityFromEventEntities() { prepareTargetEdOrgMocks(); Set<Entity> entities = new HashSet<Entity>(); entities.add(section1); entities.add(section2); SecurityEvent se = builder.createSecurityEvent(this.getClass().getName(), URI.create(ONE_PART_URI), LOG_MESSAGE, null, EntityNames.SECTION, entities); Assert.assertTrue(se.getActionUri().equals(ONE_PART_URI)); Assert.assertTrue(se.getLogMessage().equals(LOG_MESSAGE)); Assert.assertTrue(se.getUserEdOrg().equals(REALM_EDORG_STATEID)); Assert.assertTrue(containsTheSame(se.getTargetEdOrgList(), Arrays.asList(EDORG_STATEID, EDORG2_STATEID))); }
### Question: ApplicationAuthorizationValidator { @SuppressWarnings("unchecked") public boolean isAuthorizedForApp(Entity app, SLIPrincipal principal) { if (principal.isAdminRealmAuthenticated()) { return isAdminVisible(app); } else { if (isAutoAuthorized(app)) { return true; } else if (!isOperatorApproved(app)) { return false; } else { Set<String> edOrgs = helper.locateDirectEdorgs(principal.getEntity()); NeutralQuery appAuthCollQuery = new NeutralQuery(); appAuthCollQuery.addCriteria(new NeutralCriteria("applicationId", "=", app.getEntityId())); appAuthCollQuery.addCriteria(new NeutralCriteria("edorgs.authorizedEdorg", NeutralCriteria.CRITERIA_IN, edOrgs)); Entity authorizedApps = repo.findOne("applicationAuthorization", appAuthCollQuery); if (authorizedApps != null) { if (isAutoApproved(app)) { return true; } else { List<String> approvedDistricts = new ArrayList<String>((List<String>) app.getBody().get("authorized_ed_orgs")); List<String> myDistricts = helper.getDistricts(edOrgs); approvedDistricts.retainAll(myDistricts); return !approvedDistricts.isEmpty(); } } } } return false; } @SuppressWarnings("unchecked") boolean isAuthorizedForApp(Entity app, SLIPrincipal principal); Set<String> getAuthorizingEdOrgsForApp(String clientId); }### Answer: @Test public void testStaffUser() throws InterruptedException { SLIPrincipal principal = new SLIPrincipal(); principal.setEntity(staff1); principal.setEdOrg(lea1.getEntityId()); principal.setRealm(leaRealm.getEntityId()); injector.setSecurityContext(principal, false); assertTrue("Can see autoApp", validator.isAuthorizedForApp(autoApp, principal)); assertTrue("Can see approvedApp", validator.isAuthorizedForApp(approvedApp, principal)); assertFalse("Cannot see notOperatorApproved", validator.isAuthorizedForApp(notOperatorApproved, principal)); assertFalse("Cannot see approvedAppWithoutOperator", validator.isAuthorizedForApp(approvedAppWithoutOperator, principal)); assertFalse("Cannot see adminApp", validator.isAuthorizedForApp(adminApp, principal)); assertFalse("Cannot see noAuthApp", validator.isAuthorizedForApp(noAuthApp, principal)); assertFalse("Cannot see nonApprovedApp", validator.isAuthorizedForApp(nonApprovedApp, principal)); assertFalse("Cannot see notAuthorizedApp", validator.isAuthorizedForApp(notAuthorizedApp, principal)); } @Test public void testAdminUser() throws InterruptedException { SLIPrincipal principal = new SLIPrincipal(); principal.setEntity(null); principal.setEdOrg("SOMETHING"); principal.setRealm(sliRealm.getEntityId()); principal.setAdminRealmAuthenticated(true); injector.setSecurityContext(principal, false); assertFalse("Cannot see autoApp", validator.isAuthorizedForApp(autoApp, principal)); assertFalse("Cannot see approvedApp", validator.isAuthorizedForApp(approvedApp, principal)); assertTrue("Can see adminApp", validator.isAuthorizedForApp(adminApp, principal)); assertFalse("Cannot see notOperatorApproved", validator.isAuthorizedForApp(notOperatorApproved, principal)); assertFalse("Cannot see approvedAppWithoutOperator", validator.isAuthorizedForApp(approvedAppWithoutOperator, principal)); assertFalse("Cannot see noAuthApp", validator.isAuthorizedForApp(noAuthApp, principal)); assertFalse("Cannot see nonApprovedApp", validator.isAuthorizedForApp(nonApprovedApp, principal)); assertFalse("Cannot see notAuthorizedApp", validator.isAuthorizedForApp(notAuthorizedApp, principal)); }
### Question: TokenGenerator { public static String generateToken(int length) { byte[] verifierBytes = new byte[length]; random.nextBytes(verifierBytes); return getAuthorizationCodeString(verifierBytes); } static String generateToken(int length); }### Answer: @Test public void testIdGeneratorZeroLength() { String string = TokenGenerator.generateToken(0); assertEquals("", string); } @Test public void testIdGeneratorLargeLength() { String string = TokenGenerator.generateToken(1000); assertEquals(1000, string.length()); for (int i = 0; i < string.length(); i++) { assertTrue(Character.isDigit(string.charAt(i)) \|\| Character.isLetter(string.charAt(i))); } } @Test public void testEdgeCharacters() { boolean foundChars = false; for (int i = 0; i < 25; i++) { String token = TokenGenerator.generateToken(10000); foundChars = token.indexOf('a') > -1 && token.indexOf('u') > -1 && token.indexOf('z') > -1 && token.indexOf('w') > -1 && token.indexOf('0') > -1 && token.indexOf('9') > -1; if (foundChars) break; } assertTrue(foundChars); }
### Question: EntityDefinition { public void setSchema(NeutralSchema neutralSchema) { this.schema = neutralSchema; this.referenceFields = new LinkedHashMap<String, ReferenceSchema>(); if (this.schema != null) { addRefs("", neutralSchema); } } protected EntityDefinition(String type, String resourceName, String collectionName, EntityService service, boolean supportsAggregates); protected EntityDefinition(String type, String dbType, String resourceName, String collectionName, EntityService service, boolean supportsAggregates, boolean skipContextValidation, boolean pullTypeFromEntity, NeutralCriteria typeCriteria, boolean supportsPut, boolean supportsPatch); boolean hasArrayField(String fieldName); NeutralSchema getSchema(); void setSchema(NeutralSchema neutralSchema); Iterable<String> getReferenceFieldNames(String resource); final Map<String, ReferenceSchema> getReferenceFields(); final void addReferencingEntity(EntityDefinition entityDefinition); final Collection<EntityDefinition> getReferencingEntities(); String getStoredCollectionName(); String getType(); String getResourceName(); EntityService getService(); boolean isOfType(String id); boolean isRestrictedForLogging(); static void setDefaultRepo(Repository<Entity> defaultRepo); static Repository<Entity> getDefaultRepo(); boolean supportsAggregates(); boolean skipContextValidation(); boolean wrapperEntity(); String getDbType(); NeutralCriteria getTypeCriteria(); boolean supportsPut(); boolean supportsPatch(); }### Answer: @Test public void testSetSchema() { NeutralSchema mockSchema = new ComplexSchema(); populate(mockSchema); entityDefinition.setSchema(mockSchema); Map<String, ReferenceSchema> referenceFields = entityDefinition.getReferenceFields(); assertEquals("Expected map with two entries", 3, referenceFields.size()); ReferenceSchema stringSchema = referenceFields.get("StringSchema1"); assertNull("Expected null schema", stringSchema); ReferenceSchema referenceSchema = referenceFields.get("ReferenceSchema1"); assertNotNull("Expected non-null schema", referenceSchema); assertEquals("Expected different reference type", referenceSchema.getType(), "straightReferenceTest"); ReferenceSchema listSchema = referenceFields.get("ListSchema1"); assertNotNull("Expected non-null schema", listSchema); assertEquals("Expected different reference type", listSchema.getType(), "listReferenceTest"); assertTrue(entityDefinition.hasArrayField("ListSchema1")); assertFalse(entityDefinition.hasArrayField("StringSchema1")); assertFalse(entityDefinition.hasArrayField("Foo")); }
### Question: SessionCache { public void put(String token, OAuth2Authentication auth) { if (auth != null) { this.sessions.put(new Element(token, auth)); replicate(token, auth); } else { LOG.warn("Attempting to cache null session!"); } } void put(String token, OAuth2Authentication auth); OAuth2Authentication get(String token); void remove(String token); void clear(); }### Answer: @Test public void testPut() { Authentication userAuthentication = new PreAuthenticatedAuthenticationToken(new SLIPrincipal("1234"), "auth", Arrays.asList(Right.FULL_ACCESS)); sessions.put(TOKEN, new OAuth2Authentication(new ClientToken("the", "ordinary", Collections.singleton("man")), userAuthentication)); Assert.assertNotNull(sessions.get(TOKEN)); }
### Question: SessionCache { public void remove(String token) { this.sessions.remove(token); try { ObjectMessage msg = createMessage(token, null, REMOVE); tp.send(msg); } catch (JMSException e) { LOG.error("Failed to replicate session cache entry", e); } } void put(String token, OAuth2Authentication auth); OAuth2Authentication get(String token); void remove(String token); void clear(); }### Answer: @Test @Ignore public void testRemove() { Authentication userAuthentication = new PreAuthenticatedAuthenticationToken(new SLIPrincipal("1234"), "auth", Arrays.asList(Right.FULL_ACCESS)); sessions.put(TOKEN2, new OAuth2Authentication(new ClientToken("the", "ordinary", Collections.singleton("man")), userAuthentication)); Assert.assertNotNull(sessions.get(TOKEN2)); sessions.remove(TOKEN2); Assert.assertNull(sessions.get(TOKEN2)); }
### Question: DefaultSelectorDocument implements SelectorDocument { protected List<EntityBody> filterFields(List<EntityBody> results, SelectorQueryPlan plan) { List<EntityBody> filteredList = filterIncludeFields(results, plan); filteredList = filterExcludeFields(filteredList, plan); return filteredList; } @Override List<EntityBody> aggregate(SelectorQuery selectorQuery, final NeutralQuery constraint); List<EntityBody> getEntitySubList(List<EntityBody> list, String field, String value); static final int EMBEDDED_DOCUMENT_LIMIT; }### Answer: @Test public void testFilterFields() { SelectorQueryPlan plan = new SelectorQueryPlan(); List<EntityBody> results = createResults(); plan.getIncludeFields().add("field1"); List<EntityBody> out = defaultSelectorDocument.filterFields(results, plan); assertEquals("Should match", 1, out.size()); EntityBody body = out.get(0); assertTrue("Should be true", body.containsKey("field1")); assertFalse("Should be false", body.containsKey("field2")); assertFalse("Should be false", body.containsKey("field3")); plan.getIncludeFields().clear(); plan.getIncludeFields().add("field1"); plan.getIncludeFields().add("field2"); out = defaultSelectorDocument.filterFields(results, plan); assertEquals("Should match", 1, out.size()); body = out.get(0); assertTrue("Should be true", body.containsKey("field1")); assertTrue("Should be true", body.containsKey("field2")); assertFalse("Should be false", body.containsKey("field3")); plan.getIncludeFields().clear(); plan.getExcludeFields().add("field1"); out = defaultSelectorDocument.filterFields(results, plan); assertEquals("Should match", 1, out.size()); body = out.get(0); assertFalse("Should be false", body.containsKey("field1")); assertFalse("Should be false", body.containsKey("field2")); assertFalse("Should be false", body.containsKey("field3")); plan.getIncludeFields().clear(); plan.getExcludeFields().clear(); plan.getExcludeFields().add("field1"); plan.getIncludeFields().add("field1"); out = defaultSelectorDocument.filterFields(results, plan); assertEquals("Should match", 1, out.size()); body = out.get(0); assertFalse("Should be false", body.containsKey("field1")); assertFalse("Should be false", body.containsKey("field2")); assertFalse("Should be false", body.containsKey("field3")); plan.getIncludeFields().clear(); plan.getExcludeFields().clear(); out = defaultSelectorDocument.filterFields(results, plan); assertEquals("Should match", 1, out.size()); body = out.get(0); assertFalse("Should be false", body.containsKey("field1")); assertFalse("Should be false", body.containsKey("field2")); assertFalse("Should be false", body.containsKey("field3")); }
### Question: DefaultSelectorDocument implements SelectorDocument { protected List<EntityBody> getEmbeddedEntities(List<EntityBody> previousEntities, Type currentType) { List<EntityBody> embeddedBodyList = new ArrayList<EntityBody>(); String currType = StringUtils.lowercaseFirstLetter(currentType.getName()); for (EntityBody body : previousEntities) { if (body.containsKey(currType)) { embeddedBodyList.addAll((Collection<? extends EntityBody>) body.get(currType)); } } return embeddedBodyList; } @Override List<EntityBody> aggregate(SelectorQuery selectorQuery, final NeutralQuery constraint); List<EntityBody> getEntitySubList(List<EntityBody> list, String field, String value); static final int EMBEDDED_DOCUMENT_LIMIT; }### Answer: @Test public void testGetEmbeddedEntities() { ClassType classType = mock(ClassType.class); when(classType.getName()).thenReturn("StudentSectionAssociation"); List<EntityBody> embeddedEntities = defaultSelectorDocument.getEmbeddedEntities(createEmbeddedEntity(), classType); assertEquals(embeddedEntities.size(), 1); }
### Question: DefaultSelectorDocument implements SelectorDocument { protected void addChildTypesToQuery(Type currentType, SelectorQueryPlan selectorQueryPlan, NeutralQuery neutralQuery) { List<Object> childQueries = selectorQueryPlan.getChildQueryPlans(); List<String> embeddedFields = new ArrayList<String>(); for (Object plan : childQueries) { SelectorQuery query = (SelectorQuery) plan; for (Type key : query.keySet()) { String childType = StringUtils.uncapitalise(key.getName()); if (currentType.getName().equalsIgnoreCase(EmbeddedDocumentRelations.getParentEntityType(childType))) { embeddedFields.add(childType); } } } neutralQuery.setEmbeddedFields(embeddedFields); } @Override List<EntityBody> aggregate(SelectorQuery selectorQuery, final NeutralQuery constraint); List<EntityBody> getEntitySubList(List<EntityBody> list, String field, String value); static final int EMBEDDED_DOCUMENT_LIMIT; }### Answer: @Test public void testAddChildTypesToQuery() { ClassType parentType = mock(ClassType.class); when(parentType.getName()).thenReturn("Section"); ClassType childType = mock(ClassType.class); when(childType.getName()).thenReturn("StudentSectionAssociation"); ClassType nonChildType = mock(ClassType.class); when(nonChildType.getName()).thenReturn("StudentParentAssociation"); SelectorQuery childQuery = new SelectorQuery(); childQuery.put(childType, new SelectorQueryPlan()); List<Object> childQueryPlans = new ArrayList<Object>(); childQueryPlans.add(childQuery); SelectorQueryPlan plan = new SelectorQueryPlan(); plan.setChildQueryPlans(childQueryPlans); NeutralQuery query = new NeutralQuery(); defaultSelectorDocument.addChildTypesToQuery(parentType, plan, query); assertEquals("Should match", 1, query.getEmbeddedFields().size()); assertEquals("Should match", "studentSectionAssociation", query.getEmbeddedFields().get(0)); query = new NeutralQuery(); defaultSelectorDocument.addChildTypesToQuery(parentType, new SelectorQueryPlan(), query); assertEquals("Should match", 0, query.getEmbeddedFields().size()); childQuery = new SelectorQuery(); childQuery.put(nonChildType, new SelectorQueryPlan()); childQueryPlans = new ArrayList<Object>(); childQueryPlans.add(childQuery); plan = new SelectorQueryPlan(); plan.setChildQueryPlans(childQueryPlans); query = new NeutralQuery(); defaultSelectorDocument.addChildTypesToQuery(parentType, new SelectorQueryPlan(), query); assertEquals("Should match", 0, query.getEmbeddedFields().size()); }
### Question: SemanticSelector extends HashMap<Type, List<SelectorElement>> implements SelectorQueryVisitable { public void addSelector(final Type type, final SelectorElement se) { if (this.containsKey(type)) { this.get(type).add(se); } else { this.put(type, new ArrayList<SelectorElement>(Arrays.asList(se))); } } void addSelector(final Type type, final SelectorElement se); @Override SelectorQueryPlan accept(SelectorQueryVisitor selectorQueryVisitor); @Override String toString(); }### Answer: @Test public void testAddSelector() { final Type testType = mock(Type.class); final SelectorElement se = mock(SelectorElement.class); selector.addSelector(testType, se); assertNotNull(selector.get(testType)); assertEquals(1, selector.get(testType).size()); selector.addSelector(testType, mock(BooleanSelectorElement.class)); assertEquals(2, selector.get(testType).size()); }

Subsets and Splits

No saved queries yet

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