コード例 #1
0
  @Test
  public void testCRUDEntityRepository() {

    // clean up the existing student data
    repository.deleteAll("student", null);

    // create new student entity
    Map<String, Object> student = buildTestStudentEntity();

    // test save
    Entity saved = repository.create("student", student);
    String id = saved.getEntityId();
    assertTrue(!id.equals(""));

    // test findAll
    NeutralQuery neutralQuery = new NeutralQuery();
    neutralQuery.setOffset(0);
    neutralQuery.setLimit(20);
    Iterable<Entity> entities = repository.findAll("student", neutralQuery);
    assertNotNull(entities);
    Entity found = entities.iterator().next();
    assertEquals(found.getBody().get("birthDate"), student.get("birthDate"));
    assertEquals((found.getBody()).get("firstName"), "Jane");
    assertEquals((found.getBody()).get("lastName"), "Doe");

    // test find by id
    Entity foundOne = repository.findById("student", saved.getEntityId());
    assertNotNull(foundOne);
    assertEquals(foundOne.getBody().get("birthDate"), student.get("birthDate"));
    assertEquals((found.getBody()).get("firstName"), "Jane");

    // test update
    found.getBody().put("firstName", "Mandy");
    assertTrue(repository.update("student", found, false));
    entities = repository.findAll("student", neutralQuery);
    assertNotNull(entities);
    Entity updated = entities.iterator().next();
    assertEquals(updated.getBody().get("firstName"), "Mandy");

    // test delete by id
    Map<String, Object> student2Body = buildTestStudentEntity();
    Entity student2 = repository.create("student", student2Body);
    entities = repository.findAll("student", neutralQuery);
    assertNotNull(entities.iterator().next());
    repository.delete("student", student2.getEntityId());
    Entity zombieStudent = repository.findById("student", student2.getEntityId());
    assertNull(zombieStudent);

    assertFalse(repository.delete("student", student2.getEntityId()));

    // test deleteAll by entity type
    repository.deleteAll("student", null);
    entities = repository.findAll("student", neutralQuery);
    assertFalse(entities.iterator().hasNext());
  }
コード例 #2
0
  private Entity createEducationOrganizationEntity(
      String stateOrgId, String type, String organizationCategory, List<String> parentRefs) {
    Random rand = new Random();
    Map<String, Object> body = new HashMap<String, Object>();
    List<Map<String, String>> addresses = new ArrayList<Map<String, String>>();
    Map<String, String> address = new HashMap<String, String>();
    List<String> organizationCategories = new ArrayList<String>();

    /*
      	    <xs:enumeration value="State Education Agency" />
    <xs:enumeration value="Education Service Center" />
    <xs:enumeration value="Local Education Agency" />
    <xs:enumeration value="School" />
          */
    organizationCategories.add(organizationCategory);
    body.put(ParameterConstants.ORGANIZATION_CATEGORIES, organizationCategories);

    address.put("streetNumberName", rand.nextInt(100) + " Hill Street");
    address.put("city", "My City");
    address.put("stateAbbreviation", "IL");
    address.put("postalCode", "1235");
    addresses.add(address);
    body.put("address", addresses);

    if (parentRefs != null && !parentRefs.isEmpty()) {
      body.put(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, parentRefs);
    }
    body.put("nameOfInstitution", stateOrgId + "Name");
    body.put(ParameterConstants.STATE_ORGANIZATION_ID, stateOrgId);
    return repository.create(type, body, EntityNames.EDUCATION_ORGANIZATION);
  }
コード例 #3
0
  @Test
  public void testUpdateRetry() {
    TenantContext.setTenantId("SLIUnitTest");
    repository.deleteAll("student", null);

    DBObject indexKeys = new BasicDBObject("body.cityOfBirth", 1);
    mongoTemplate.getCollection("student").ensureIndex(indexKeys);

    repository.create("student", buildTestStudentEntity());

    Entity entity = repository.findOne("student", new NeutralQuery());
    Map<String, Object> studentBody = entity.getBody();
    studentBody.put("cityOfBirth", "ABC");

    Entity studentEntity =
        new MongoEntity("student", entity.getEntityId(), studentBody, entity.getMetaData());
    repository.updateWithRetries("student", studentEntity, 5);

    NeutralQuery neutralQuery = new NeutralQuery();
    neutralQuery.addCriteria(new NeutralCriteria("cityOfBirth=ABC"));
    assertEquals(1, repository.count("student", neutralQuery));

    repository.deleteAll("student", null);
    mongoTemplate.getCollection("student").dropIndex(indexKeys);
  }
コード例 #4
0
  @Test
  public void testTimestamps() throws Exception {

    // clean up the existing student data
    repository.deleteAll("student", null);

    // create new student entity
    Map<String, Object> student = buildTestStudentEntity();

    // test save
    Entity saved = repository.create("student", student);

    DateTime created = new DateTime(saved.getMetaData().get(EntityMetadataKey.CREATED.getKey()));
    DateTime updated = new DateTime(saved.getMetaData().get(EntityMetadataKey.UPDATED.getKey()));

    assertEquals(created, updated);

    saved.getBody().put("cityOfBirth", "Evanston");

    // Needs to be here to prevent cases where code execution is so fast,
    // there
    // is no difference between create/update times
    Thread.sleep(2);

    repository.update("student", saved, false);

    updated = new DateTime(saved.getMetaData().get(EntityMetadataKey.UPDATED.getKey()));

    assertTrue(updated.isAfter(created));
  }
コード例 #5
0
 @Test
 public void testCreateWithMetadata() {
   repository.deleteAll("student", null);
   Map<String, Object> studentBody = buildTestStudentEntity();
   Map<String, Object> studentMetaData = new HashMap<String, Object>();
   repository.create("student", studentBody, studentMetaData, "student");
   assertEquals(1, repository.count("student", new NeutralQuery()));
 }
コード例 #6
0
  @Test
  public void testFindIdsByQuery() {
    repository.deleteAll("student", null);
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    NeutralQuery neutralQuery = new NeutralQuery();
    neutralQuery.setOffset(0);
    neutralQuery.setLimit(100);

    Iterable<String> ids = repository.findAllIds("student", neutralQuery);
    List<String> idList = new ArrayList<String>();
    for (String id : ids) {
      idList.add(id);
    }

    assertEquals(5, idList.size());
  }
コード例 #7
0
  @Test
  public void testCount() {
    repository.deleteAll("student", null);

    DBObject indexKeys = new BasicDBObject("body.cityOfBirth", 1);
    mongoTemplate.getCollection("student").ensureIndex(indexKeys);

    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    Map<String, Object> oddStudent = buildTestStudentEntity();
    oddStudent.put("cityOfBirth", "Nantucket");
    repository.create("student", oddStudent);
    assertEquals(5, repository.count("student", new NeutralQuery()));
    NeutralQuery neutralQuery = new NeutralQuery();
    neutralQuery.addCriteria(new NeutralCriteria("cityOfBirth=Nantucket"));
    assertEquals(1, repository.count("student", neutralQuery));

    repository.deleteAll("student", null);
    mongoTemplate.getCollection("student").dropIndex(indexKeys);
  }
コード例 #8
0
  @Test
  public void testDeleteAll() {
    repository.deleteAll("student", null);

    DBObject indexKeys = new BasicDBObject("body.firstName", 1);
    mongoTemplate.getCollection("student").ensureIndex(indexKeys);

    Map<String, Object> studentMap = buildTestStudentEntity();
    studentMap.put("firstName", "John");
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", buildTestStudentEntity());
    repository.create("student", studentMap);
    assertEquals(5, repository.count("student", new NeutralQuery()));
    NeutralQuery neutralQuery = new NeutralQuery();
    neutralQuery.addCriteria(new NeutralCriteria("firstName=John"));
    repository.deleteAll("student", neutralQuery);
    assertEquals(4, repository.count("student", new NeutralQuery()));

    repository.deleteAll("student", null);
    mongoTemplate.getCollection("student").dropIndex(indexKeys);
  }
コード例 #9
0
  private String insertAttendanceEventData(boolean skipFirst) {
    // Clear attendance collection.
    repository.deleteAll("attendance", null);

    // Populate the attendance record to be deleted, and add it to the db.
    Map<String, Object> attendanceMap = new HashMap<String, Object>();
    List<Map<String, String>> attendanceEvents = getAttendanceEvents(skipFirst);
    attendanceMap.put("attendanceEvent", attendanceEvents);
    attendanceMap.put("schoolId", "schoolId1");
    attendanceMap.put("schoolYear", "2011-2012");
    attendanceMap.put("studentId", "studentId1");
    repository.create("attendance", attendanceMap);

    // Get the db id of the attendance record; there is only one.
    NeutralQuery neutralQuery = new NeutralQuery();
    Entity attendance = repository.findOne("attendance", neutralQuery);
    return attendance.getEntityId();
  }
コード例 #10
0
  private String prepareSafeDeleteGradingPeriodLeafData() {
    DBObject indexKeys = new BasicDBObject("body.beginDate", 1);
    mongoTemplate.getCollection("gradingPeriod").ensureIndex(indexKeys);

    // create a minimal gradingPeriod document
    Map<String, Object> gradingPeriodIdentity = new HashMap<String, Object>();
    gradingPeriodIdentity.put("gradingPeriod", "gradingPeriod1");
    gradingPeriodIdentity.put("schoolYear", "2011-2012");
    gradingPeriodIdentity.put("schoolId", "schoolId1");
    Map<String, Object> gradingPeriodBody = new HashMap<String, Object>();
    gradingPeriodBody.put("gradingPeriodIdentity", gradingPeriodIdentity);
    gradingPeriodBody.put("beginDate", "beginDate1");
    repository.create("gradingPeriod", gradingPeriodBody);

    // get the db id of the gradingPeriod - there is only one
    NeutralQuery neutralQuery = new NeutralQuery();
    Entity gradingPeriod1 = repository.findOne("gradingPeriod", neutralQuery);
    return gradingPeriod1.getEntityId();
  }
コード例 #11
0
  @SuppressWarnings("unchecked")
  @Test
  public void testSort() {

    // clean up the existing student data
    repository.deleteAll("student", null);

    // create new student entity
    Map<String, Object> body1 = buildTestStudentEntity();
    Map<String, Object> body2 = buildTestStudentEntity();
    Map<String, Object> body3 = buildTestStudentEntity();
    Map<String, Object> body4 = buildTestStudentEntity();

    body1.put("firstName", "Austin");
    body2.put("firstName", "Jane");
    body3.put("firstName", "Mary");
    body4.put("firstName", "Suzy");

    body1.put("performanceLevels", new String[] {"1"});
    body2.put("performanceLevels", new String[] {"2"});
    body3.put("performanceLevels", new String[] {"3"});
    body4.put("performanceLevels", new String[] {"4"});

    // save entities
    repository.create("student", body1);
    repository.create("student", body2);
    repository.create("student", body3);
    repository.create("student", body4);

    // sort entities by firstName with ascending order
    NeutralQuery sortQuery1 = new NeutralQuery();
    sortQuery1.setSortBy("firstName");
    sortQuery1.setSortOrder(NeutralQuery.SortOrder.ascending);
    sortQuery1.setOffset(0);
    sortQuery1.setLimit(100);

    Iterable<Entity> entities = repository.findAll("student", sortQuery1);
    assertNotNull(entities);
    Iterator<Entity> it = entities.iterator();
    assertEquals("Austin", it.next().getBody().get("firstName"));
    assertEquals("Jane", it.next().getBody().get("firstName"));
    assertEquals("Mary", it.next().getBody().get("firstName"));
    assertEquals("Suzy", it.next().getBody().get("firstName"));

    // sort entities by firstName with descending order
    NeutralQuery sortQuery2 = new NeutralQuery();
    sortQuery2.setSortBy("firstName");
    sortQuery2.setSortOrder(NeutralQuery.SortOrder.descending);
    sortQuery2.setOffset(0);
    sortQuery2.setLimit(100);
    entities = repository.findAll("student", sortQuery2);
    assertNotNull(entities);
    it = entities.iterator();
    assertEquals("Suzy", it.next().getBody().get("firstName"));
    assertEquals("Mary", it.next().getBody().get("firstName"));
    assertEquals("Jane", it.next().getBody().get("firstName"));
    assertEquals("Austin", it.next().getBody().get("firstName"));

    // sort entities by performanceLevels which is an array with ascending
    // order
    NeutralQuery sortQuery3 = new NeutralQuery();
    sortQuery3.setSortBy("performanceLevels");
    sortQuery3.setSortOrder(NeutralQuery.SortOrder.ascending);
    sortQuery3.setOffset(0);
    sortQuery3.setLimit(100);
    entities = repository.findAll("student", sortQuery3);
    assertNotNull(entities);
    it = entities.iterator();
    assertEquals("1", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
    assertEquals("2", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
    assertEquals("3", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
    assertEquals("4", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));

    // sort entities by performanceLevels which is an array with descending
    // order
    NeutralQuery sortQuery4 = new NeutralQuery();
    sortQuery4.setSortBy("performanceLevels");
    sortQuery4.setSortOrder(NeutralQuery.SortOrder.descending);
    sortQuery4.setOffset(0);
    sortQuery4.setLimit(100);
    entities = repository.findAll("student", sortQuery4);
    assertNotNull(entities);
    it = entities.iterator();
    assertEquals("4", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
    assertEquals("3", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
    assertEquals("2", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
    assertEquals("1", ((List<String>) (it.next().getBody().get("performanceLevels"))).get(0));
  }
コード例 #12
0
  @Test
  public void testSchoolLineage() {
    NeutralQuery query = null;

    repository.deleteAll(EntityNames.EDUCATION_ORGANIZATION, null);

    DBObject indexKeys = new BasicDBObject("body." + ParameterConstants.STATE_ORGANIZATION_ID, 1);
    mongoTemplate.getCollection(EntityNames.EDUCATION_ORGANIZATION).ensureIndex(indexKeys);
    mongoTemplate
        .getCollection(EntityNames.EDUCATION_ORGANIZATION)
        .ensureIndex(new BasicDBObject("metaData.edOrgs", 1), new BasicDBObject("sparse", true));

    // Add a school
    Entity school = createEducationOrganizationEntity("school1", "school", "School", null);
    Set<String> expectedEdOrgs = new HashSet();
    expectedEdOrgs.add(school.getEntityId());
    assertTrue(
        "School not found in lineage.", schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Add an SEA
    Entity sea =
        createEducationOrganizationEntity(
            "sea1", "stateEducationAgency", "State Education Agency", null);
    assertTrue(
        "After adding SEA expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Add an LEA
    List<String> parentRefs = new ArrayList<String>(Arrays.asList(sea.getEntityId()));
    Entity lea =
        createEducationOrganizationEntity(
            "lea1", "localEducationAgency", "Local Education Agency", parentRefs);
    assertTrue(
        "After adding LEA expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // doUpdate School parent ref to LEA
    List<String> parentRefsUpdate = new ArrayList<String>(Arrays.asList(lea.getEntityId()));
    query =
        new NeutralQuery(
            new NeutralCriteria("_id", NeutralCriteria.OPERATOR_EQUAL, school.getEntityId()));
    Update update =
        new Update()
            .set("body." + ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, parentRefsUpdate);
    repository.doUpdate(EntityNames.EDUCATION_ORGANIZATION, query, update);
    expectedEdOrgs.add(lea.getEntityId());
    expectedEdOrgs.add(sea.getEntityId());
    assertTrue(
        "After updating school parent ref expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Patch LEA parent ref to an undefined id
    List<String> parentRefsPatch = new ArrayList<String>(Arrays.asList("undefinedId"));
    Map<String, Object> newValues = new HashMap<String, Object>();
    newValues.put(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, parentRefsPatch);
    repository.patch(
        "localEducationEntity", EntityNames.EDUCATION_ORGANIZATION, lea.getEntityId(), newValues);
    expectedEdOrgs.remove(sea.getEntityId());
    assertTrue(
        "After updating school parent ref expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Update LEA to set parent ref back to SEA
    repository.update(EntityNames.EDUCATION_ORGANIZATION, lea, false);
    expectedEdOrgs.add(sea.getEntityId());
    assertTrue(
        "After updating school parent ref expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Delete LEA - lineage should be recalculated
    repository.delete(EntityNames.EDUCATION_ORGANIZATION, lea.getEntityId());
    expectedEdOrgs.remove(lea.getEntityId());
    expectedEdOrgs.remove(sea.getEntityId());
    assertTrue(
        "After deleting lea expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Insert LEA with no parent ref to SEA
    lea.getBody().remove(ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE);
    Entity insertedLea =
        ((MongoEntityRepository) repository).insert(lea, EntityNames.EDUCATION_ORGANIZATION);
    expectedEdOrgs.add(lea.getEntityId());
    assertTrue(
        "After re-adding LEA with no parent ref expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // findAndUpdate School parent ref to SEA
    List<String> parentRefsSEA = new ArrayList<String>(Arrays.asList(sea.getEntityId()));
    query =
        new NeutralQuery(
            new NeutralCriteria("_id", NeutralCriteria.OPERATOR_EQUAL, school.getEntityId()));
    update =
        new Update()
            .set("body." + ParameterConstants.PARENT_EDUCATION_AGENCY_REFERENCE, parentRefsSEA);
    repository.findAndUpdate(EntityNames.EDUCATION_ORGANIZATION, query, update);
    expectedEdOrgs.remove(lea.getEntityId());
    expectedEdOrgs.add(sea.getEntityId());
    assertTrue(
        "After updating school parent ref to SEA, expected edOrgs not found in lineage.",
        schoolLineageIs(school.getEntityId(), expectedEdOrgs));

    // Clear lineage for negative tests
    clearSchoolLineage(school);

    // Create an unrelated entity type and make sure school lineage isn't recalculated
    repository.create("student", buildTestStudentEntity());
    assertTrue(
        "After adding a student lineage school lineage should not change.",
        schoolLineageIs(school.getEntityId(), new HashSet<String>()));

    // Patch an edOrg non-parent-ref and make sure school lineage isn't recalculated
    newValues = new HashMap<String, Object>();
    newValues.put("body.nameOfInstitution", "updatedName");
    repository.patch("school", EntityNames.EDUCATION_ORGANIZATION, school.getEntityId(), newValues);
    assertTrue(
        "Updating a school non-parent ref should not change school lineage.",
        schoolLineageIs(school.getEntityId(), new HashSet<String>()));

    mongoTemplate.getCollection(EntityNames.EDUCATION_ORGANIZATION).drop();
  }
コード例 #13
0
  private void prepareSafeDeleteGradingPeriodReferenceData(String idToDelete) {
    DBObject indexKeys = new BasicDBObject("body.gradingPeriodId", 1);
    mongoTemplate.getCollection("grade").ensureIndex(indexKeys);
    mongoTemplate.getCollection("gradeBookEntry").ensureIndex(indexKeys);
    mongoTemplate.getCollection("reportCard").ensureIndex(indexKeys);
    mongoTemplate
        .getCollection(MongoRepository.CUSTOM_ENTITY_COLLECTION)
        .ensureIndex("metaData." + MongoRepository.CUSTOM_ENTITY_ENTITY_ID);
    DBObject indexKeysList = new BasicDBObject("body.gradingPeriodReference", 1);
    mongoTemplate.getCollection("session").ensureIndex(indexKeysList);

    // add a custom entity referencing the entity to be deleted
    Map<String, Object> customEntityMetaData = new HashMap<String, Object>();
    customEntityMetaData.put(MongoRepository.CUSTOM_ENTITY_ENTITY_ID, idToDelete);
    Map<String, Object> customEntityBody = new HashMap<String, Object>();
    customEntityBody.put("customBodyData", "customData1");
    repository.create(
        MongoRepository.CUSTOM_ENTITY_COLLECTION,
        customEntityBody,
        customEntityMetaData,
        MongoRepository.CUSTOM_ENTITY_COLLECTION);
    customEntityMetaData.put(MongoRepository.CUSTOM_ENTITY_ENTITY_ID, "nonMatchingId");
    customEntityBody.put("customBodyData", "customData2");
    repository.create(
        MongoRepository.CUSTOM_ENTITY_COLLECTION,
        customEntityBody,
        customEntityMetaData,
        MongoRepository.CUSTOM_ENTITY_COLLECTION);

    // add referencing grade entities
    Map<String, Object> gradeMap = new HashMap<String, Object>();
    gradeMap.put("studentId", "studentId1");
    gradeMap.put("sectionId", "sectionId1");
    gradeMap.put("schoolYear", "2011-2012");
    gradeMap.put("gradingPeriodId", "noMatch");
    repository.create("grade", gradeMap); // add one non-matching document
    gradeMap.put("studentId", "studentId2");
    gradeMap.put("sectionId", "sectionId2");
    gradeMap.put("schoolYear", "2011-2012");
    gradeMap.put("gradingPeriodId", idToDelete);
    repository.create("grade", gradeMap); // add matching document

    // // add referencing gradeBookEntry entities - excluded since the
    // reference type is the same as grade
    // Map<String, Object> gradeBookEntryMap = new HashMap<String,
    // Object>();
    // gradeBookEntryMap.put("gradebookEntryType", "gradebookEntryType1");
    // gradeBookEntryMap.put("sectionId", "sectionId1");
    // gradeBookEntryMap.put("gradingPeriodId", idToDelete);
    // repository.create("gradeBookEntry", gradeBookEntryMap); // add one
    // non-matching document
    // gradeBookEntryMap.put("gradebookEntryType", "gradebookEntryType2");
    // gradeBookEntryMap.put("sectionId", "sectionId2");
    // gradeBookEntryMap.put("gradingPeriodId", "noMatch");
    // repository.create("gradeBookEntry", gradeBookEntryMap); // add
    // matching document

    // add referencing resportCard entities
    Map<String, Object> reportCardMap = new HashMap<String, Object>();
    reportCardMap.put("schoolYear", "2011-2012");
    reportCardMap.put("studentId", "studentId1");
    reportCardMap.put("gradingPeriodId", "noMatch");
    repository.create("reportCard", reportCardMap); // add one non-matching
    // document
    reportCardMap.put("schoolYear", "2011-2012");
    reportCardMap.put("studentId", "studentId2");
    reportCardMap.put("gradingPeriodId", idToDelete);
    repository.create("reportCard", reportCardMap); // add matching document

    // create a minimal session document
    Map<String, Object> sessionMap = new HashMap<String, Object>();
    sessionMap.put("sessionName", "session1");
    sessionMap.put("schoolId", "schoolId1");
    List<String> gradingPeriodRefArray = new ArrayList<String>();
    gradingPeriodRefArray.add("dog");
    sessionMap.put("gradingPeriodReference", gradingPeriodRefArray);
    repository.create("session", sessionMap);
    sessionMap.put("sessionName", "session2");
    sessionMap.put("schoolId", "schoolId2");
    gradingPeriodRefArray.add(idToDelete);
    gradingPeriodRefArray.add("mousearama");
    sessionMap.put("gradingPeriodReference", gradingPeriodRefArray);
    repository.create("session", sessionMap);
  }