GradebookServiceNewTest.java

/**********************************************************************************
 *
 * $Id: GradebookServiceNewTest.java 105079 2012-02-24 23:08:11Z ottenhoff@longsight.com $
 *
 ***********************************************************************************
 *
 * Copyright (c) 2005, 2006, 2008, 2009 The Sakai Foundation, The MIT Corporation
 *
 * Licensed under the Educational Community License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.opensource.org/licenses/ECL-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **********************************************************************************/
package org.sakaiproject.tool.gradebook.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import junit.framework.Assert;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.sakaiproject.component.gradebook.GradebookDefinition;
import org.sakaiproject.component.gradebook.VersionedExternalizable;
import org.sakaiproject.section.api.coursemanagement.Course;
import org.sakaiproject.section.api.coursemanagement.CourseSection;
import org.sakaiproject.section.api.facade.Role;
import org.sakaiproject.service.gradebook.shared.AssessmentNotFoundException;
import org.sakaiproject.service.gradebook.shared.Assignment;
import org.sakaiproject.service.gradebook.shared.AssignmentHasIllegalPointsException;
import org.sakaiproject.service.gradebook.shared.CategoryDefinition;
import org.sakaiproject.service.gradebook.shared.CommentDefinition;
import org.sakaiproject.service.gradebook.shared.ConflictingAssignmentNameException;
import org.sakaiproject.service.gradebook.shared.GradeDefinition;
import org.sakaiproject.service.gradebook.shared.GradebookNotFoundException;
import org.sakaiproject.service.gradebook.shared.GradingScaleDefinition;
import org.sakaiproject.service.gradebook.shared.GradebookService;
import org.sakaiproject.service.gradebook.shared.InvalidGradeException;
import org.sakaiproject.tool.gradebook.AssignmentGradeRecord;
import org.sakaiproject.tool.gradebook.Category;
import org.sakaiproject.tool.gradebook.Comment;
import org.sakaiproject.tool.gradebook.GradeMapping;
import org.sakaiproject.tool.gradebook.Gradebook;
import org.sakaiproject.tool.gradebook.GradingEvents;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.InputSource;

import com.thoughtworks.xstream.converters.ConversionException;

/**
 * Test the service methods which interact with internally maintained data.
 * These methods have more complex authorization requirements.
 */
public class GradebookServiceNewTest extends GradebookTestBase {

	private static final Log log = LogFactory.getLog(GradebookServiceNewTest.class);

	private static final String GRADEBOOK_UID_NO_CAT = "gradebookNoCategories";
	private static final String ASN_TITLE1 = "Assignment #1";
	private static final String ASN_TITLE2 = "Assignment #2";
	private static final String INSTRUCTOR_UID = "Inst-1";
	private static final String TA_UID = "TA-1";
	private static final String TA_NO_SECT_UID = "TA-2";
	private static final String SECTION_NAME = "Lab 01";
	private static final String STUDENT_IN_SECTION_UID1 = "StudentInLab1";
	private static final String STUDENT_NOT_IN_SECTION_UID1 = "StudentNotInLab1";
	private static final Double ASN_POINTS1 = new Double(40.0);
	private static final Double ASN_POINTS2 = new Double(60.0);
	private Long asn1IdNoCat;
	private Long asn2IdNoCat;
	
	private static final String GRADEBOOK_UID_WITH_CAT = "gradebookWithCategories";
	private static final String STUDENT_IN_SECTION_UID2 = "StudentInLab2";
	private static final String STUDENT_NOT_IN_SECTION_UID2 = "StudentNotInLab2";
	private Long asn1IdWithCat;
	private Long asn2IdWithCat;
	private String section2Uid;
	private Long cat1Id;
	private Long cat2Id;
	private static final String CAT1_NAME = "Category 1";
	private static final String CAT2_NAME = "Category 2";
	
	

	/**
	 * @see org.springframework.test.AbstractTransactionalSpringContextTests#onSetUpInTransaction()
	 */
	protected void onSetUpInTransaction() throws Exception {
		super.onSetUpInTransaction();
		
		userManager.createUser(INSTRUCTOR_UID, null, null, null);
		userManager.createUser(TA_UID, null, null, null);
		userManager.createUser(TA_NO_SECT_UID, null, null, null);
		
		// set up gb with no categories /////////////////////
		gradebookFrameworkService.addGradebook(GRADEBOOK_UID_NO_CAT, GRADEBOOK_UID_NO_CAT);
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);

		// Set up users, enrollments, teaching assignments, and sections.
		Course courseSite1 = integrationSupport.createCourse(GRADEBOOK_UID_NO_CAT, GRADEBOOK_UID_NO_CAT, false, false, false);
		addUsersEnrollments(gradebookNoCat, Arrays.asList(new String[] {STUDENT_IN_SECTION_UID1, STUDENT_NOT_IN_SECTION_UID1}));
		
		integrationSupport.addSiteMembership(INSTRUCTOR_UID, GRADEBOOK_UID_NO_CAT, Role.INSTRUCTOR);
		
		integrationSupport.addSiteMembership(TA_UID, GRADEBOOK_UID_NO_CAT, Role.TA);
		integrationSupport.addSiteMembership(TA_NO_SECT_UID, GRADEBOOK_UID_NO_CAT, Role.TA);
		List sectionCategories1 = sectionAwareness.getSectionCategories(GRADEBOOK_UID_NO_CAT);
		CourseSection section1 = integrationSupport.createSection(courseSite1.getUuid(), SECTION_NAME,
				(String)sectionCategories1.get(0),
				new Integer(40), null, null, null, true, false, true,  false, false, false, false);
		integrationSupport.addSectionMembership(STUDENT_IN_SECTION_UID1, section1.getUuid(), Role.STUDENT);
		integrationSupport.addSectionMembership(TA_UID, section1.getUuid(), Role.TA);

		// Add internal assignments
		asn1IdNoCat = gradebookManager.createAssignment(gradebookNoCat.getId(), ASN_TITLE1, ASN_POINTS1, new Date(), Boolean.FALSE,Boolean.FALSE,Boolean.FALSE);
		asn2IdNoCat = gradebookManager.createAssignment(gradebookNoCat.getId(), ASN_TITLE2, ASN_POINTS2, new Date(), Boolean.FALSE,Boolean.FALSE,Boolean.FALSE);
		
		// set up gb with categories ///////////////////
		gradebookFrameworkService.addGradebook(GRADEBOOK_UID_WITH_CAT, GRADEBOOK_UID_WITH_CAT);
		Gradebook gradebookWithCat = gradebookManager.getGradebook(GRADEBOOK_UID_WITH_CAT);
		gradebookWithCat.setCategory_type(GradebookService.CATEGORY_TYPE_ONLY_CATEGORY);
		gradebookManager.updateGradebook(gradebookWithCat);

		// Set up users, enrollments, teaching assignments, and sections.
		Course courseSite2 = integrationSupport.createCourse(GRADEBOOK_UID_WITH_CAT, GRADEBOOK_UID_WITH_CAT, false, false, false);
		addUsersEnrollments(gradebookWithCat, Arrays.asList(new String[] {STUDENT_IN_SECTION_UID2, STUDENT_NOT_IN_SECTION_UID2}));
		
		integrationSupport.addSiteMembership(INSTRUCTOR_UID, GRADEBOOK_UID_WITH_CAT, Role.INSTRUCTOR);
		integrationSupport.addSiteMembership(TA_UID, GRADEBOOK_UID_WITH_CAT, Role.TA);
		integrationSupport.addSiteMembership(TA_NO_SECT_UID, GRADEBOOK_UID_WITH_CAT, Role.TA);
		
		List sectionCategories2 = sectionAwareness.getSectionCategories(GRADEBOOK_UID_WITH_CAT);
		CourseSection section2 = integrationSupport.createSection(courseSite2.getUuid(), SECTION_NAME,
				(String)sectionCategories2.get(0),
				new Integer(40), null, null, null, true, false, true,  false, false, false, false);
		section2Uid = section2.getUuid();
		
		integrationSupport.addSectionMembership(STUDENT_IN_SECTION_UID2, section2.getUuid(), Role.STUDENT);
		integrationSupport.addSectionMembership(TA_UID, section2.getUuid(), Role.TA);

		// Add an internal assignment.
		cat1Id = gradebookManager.createCategory(gradebookWithCat.getId(), CAT1_NAME, new Double(0), 0, 0, 0, false);
		asn1IdWithCat = gradebookManager.createAssignmentForCategory(gradebookWithCat.getId(), cat1Id, ASN_TITLE1, ASN_POINTS1, new Date(), Boolean.FALSE,Boolean.FALSE,Boolean.FALSE);
		
		cat2Id = gradebookManager.createCategory(gradebookWithCat.getId(), CAT2_NAME, new Double(0), 0, 0, 0, false);
		asn2IdWithCat = gradebookManager.createAssignmentForCategory(gradebookWithCat.getId(), cat2Id, ASN_TITLE2, ASN_POINTS2, new Date(), Boolean.FALSE,Boolean.FALSE,Boolean.FALSE);

	}

	public void testGetCategory() throws Exception{
		String className = this.getClass().getName();
		gradebookFrameworkService.addGradebook(className, className);
		Gradebook persistentGradebook = gradebookManager.getGradebook(this.getClass().getName());
		Long cate1Long = gradebookManager.createCategory(persistentGradebook.getId(), "cate 1", new Double(0.40), 0, 0, 0, false);
		Long cate2Long = gradebookManager.createCategory(persistentGradebook.getId(), "cate 2", new Double(0.60), 0, 0, 0, false);

		List list = (List) gradebookManager.getCategories(persistentGradebook.getId());

		for(int i=0; i<list.size(); i++)
		{
			Category cat = (Category) list.get(i);
			if(i == 0)
			{
				Long assgn1Long = gradebookManager.createAssignmentForCategory(persistentGradebook.getId(), cat.getId(), 
						cat.getName() + "_assignment_1", new Double(10.0), new Date(), new Boolean(false), new Boolean(true), new Boolean(false));
			}
			if(i == 1)
			{
				Long assgn3Long = gradebookManager.createAssignmentForCategory(persistentGradebook.getId(), cat.getId(), 
						cat.getName() + "_assignment_1", new Double(10.0), new Date(), new Boolean(false), new Boolean(true), new Boolean(false));
			}
			Long assign2 = gradebookManager.createAssignmentForCategory(persistentGradebook.getId(), cat.getId(), 
					cat.getName() + "_assignment_2", new Double(10.0), new Date(), new Boolean(false), new Boolean(true), new Boolean(false));
		}

		Category cat1 = gradebookManager.getCategory(cate1Long);
		Category cat2 = gradebookManager.getCategory(cate2Long);
//		System.out.println(cat1 + "---" + cat1.getName());
//		System.out.println(cat2 + "---" + cat2.getName());
	}

	public void testStudentRebuff() throws Exception {
		setAuthnId(INSTRUCTOR_UID);

		// Score the unreleased assignment.
		gradebookService.setAssignmentScoreString(GRADEBOOK_UID_NO_CAT, ASN_TITLE1, STUDENT_IN_SECTION_UID1, new String("39"), "Service Test");

		// Try to get a list of assignments as the student.
		setAuthnId(STUDENT_IN_SECTION_UID1);
		try {
			if (log.isInfoEnabled()) log.info("Ignore the upcoming authorization errors...");
			gradebookService.getAssignments(GRADEBOOK_UID_NO_CAT);
			fail();
		} catch (SecurityException e) {
		}

		// And then try to get the score.
		Double score;
		try {
			score = new Double(gradebookService.getAssignmentScoreString(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1));
			fail();
		} catch (SecurityException e) {
		}

		// try to get grades for students for item
		List grades;
		try {
			List studentIds = new ArrayList();
			studentIds.add(STUDENT_IN_SECTION_UID1);
			studentIds.add(STUDENT_NOT_IN_SECTION_UID1);
			grades = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentIds);
		} catch (SecurityException e) {
		}

		// try to get gradeDef for student for item - should return null if not released
		GradeDefinition gradeDef;
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(gradeDef.getGrade() == null);

		// Now release the assignment.
		setAuthnId(INSTRUCTOR_UID);
		org.sakaiproject.tool.gradebook.Assignment assignment = gradebookManager.getAssignment(asn1IdNoCat);
		assignment.setReleased(true);
		gradebookManager.updateAssignment(assignment);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);

		// Now see if the student gets lucky.
		setAuthnId(STUDENT_IN_SECTION_UID1);
		score = new Double(gradebookService.getAssignmentScoreString(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1));
		Assert.assertTrue(score.doubleValue() == 39.0);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(gradeDef.getGrade().equals((new Double(39).toString())));
		
		setAuthnId(STUDENT_IN_SECTION_UID1);

		Map viewableStudents = gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
		assertEquals(0, viewableStudents.size());
	}
	
	public void testGetGradeDefinitionForStudentForItem() throws Exception {
		setAuthnId(INSTRUCTOR_UID);
		
		// start with a points-based gb
		GradeDefinition gradeDef = 
			gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(gradeDef != null);
		Assert.assertEquals(GradebookService.GRADE_TYPE_POINTS, gradeDef.getGradeEntryType());
		Assert.assertEquals(STUDENT_IN_SECTION_UID1, gradeDef.getStudentUid());
		Assert.assertTrue(gradeDef.isGradeReleased() == false);
		Assert.assertNull(gradeDef.getGrade());
		Assert.assertNull(gradeDef.getGraderUid());
		Assert.assertNull(gradeDef.getDateRecorded());

		String graderComment = "grader comment";
		gradebookService.setAssignmentScoreString(GRADEBOOK_UID_NO_CAT, ASN_TITLE1, STUDENT_IN_SECTION_UID1, new String("35"), "Service Test");
		gradebookService.setAssignmentScoreComment(GRADEBOOK_UID_NO_CAT, ASN_TITLE1, STUDENT_IN_SECTION_UID1, graderComment);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(gradeDef != null);
		Assert.assertEquals(GradebookService.GRADE_TYPE_POINTS, gradeDef.getGradeEntryType());
		Assert.assertEquals(STUDENT_IN_SECTION_UID1, gradeDef.getStudentUid());
		Assert.assertTrue(gradeDef.isGradeReleased() == false);
		Assert.assertEquals("35.0", gradeDef.getGrade());
		Assert.assertEquals(INSTRUCTOR_UID, gradeDef.getGraderUid());
		Assert.assertEquals(graderComment, gradeDef.getGradeComment());
		Assert.assertNotNull(gradeDef.getDateRecorded());
		
		setAuthnId(STUDENT_IN_SECTION_UID1);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		// the grade is not released, so grade info should be null
		Assert.assertEquals(GradebookService.GRADE_TYPE_POINTS, gradeDef.getGradeEntryType());
		Assert.assertEquals(STUDENT_IN_SECTION_UID1, gradeDef.getStudentUid());
		Assert.assertTrue(gradeDef.isGradeReleased() == false);
		Assert.assertNull(gradeDef.getGrade()); // should be null if grade not released
		Assert.assertNull(gradeDef.getGradeComment()); // should be null if grade not released
		Assert.assertNull(gradeDef.getGraderUid());  // should be null if grade not released
		Assert.assertNull(gradeDef.getDateRecorded()); // should be null if grade not released
		
		// switch back to instructor and double check other grade entry types
		setAuthnId(INSTRUCTOR_UID);
		
		// %-based gradebook
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_PERCENTAGE);
		gradebookManager.updateGradebook(gradebookNoCat);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertEquals("87.5", gradeDef.getGrade());
		Assert.assertEquals(graderComment, gradeDef.getGradeComment());
		Assert.assertEquals(GradebookService.GRADE_TYPE_PERCENTAGE, gradeDef.getGradeEntryType());
		
		// letter-based gradebook
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_LETTER);
		gradebookManager.updateGradebook(gradebookNoCat);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);

		Assert.assertEquals("B+", gradeDef.getGrade());
		Assert.assertEquals(graderComment, gradeDef.getGradeComment());
		Assert.assertEquals(GradebookService.GRADE_TYPE_LETTER, gradeDef.getGradeEntryType());
		
		// the TA with standard grader perms should trigger exception for student
		// not in section
		setAuthnId(TA_UID);
		try {
			gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_NOT_IN_SECTION_UID1);
			Assert.fail();
		} catch (SecurityException se) {
			
		}
		
		// let's release the grade and make sure the student can access it
		setAuthnId(INSTRUCTOR_UID);
		org.sakaiproject.tool.gradebook.Assignment assignment = gradebookManager.getAssignment(asn1IdNoCat);
		assignment.setReleased(true);
		gradebookManager.updateAssignment(assignment);
		
		setAuthnId(STUDENT_IN_SECTION_UID1);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertEquals(GradebookService.GRADE_TYPE_LETTER, gradeDef.getGradeEntryType());
		Assert.assertEquals(STUDENT_IN_SECTION_UID1, gradeDef.getStudentUid());
		Assert.assertTrue(gradeDef.isGradeReleased());
		Assert.assertEquals("B+", gradeDef.getGrade());
        Assert.assertEquals(graderComment, gradeDef.getGradeComment());
		Assert.assertEquals(INSTRUCTOR_UID, gradeDef.getGraderUid());
		Assert.assertNotNull(gradeDef.getDateRecorded());
		
		// try to retrieve another student's score
		try {
		    gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID2);
		    fail("Did not catch a student trying to retrieve another student's grade info!");
		} catch (SecurityException se) {}
	}

	public void testAssignmentScoreComment() throws Exception {
		setAuthnId(INSTRUCTOR_UID);

		// Comment on a student score as if the Gradebook application was doing it.
		org.sakaiproject.tool.gradebook.Assignment assignment = gradebookManager.getAssignment(asn1IdNoCat);
		List<AssignmentGradeRecord> gradeRecords = new ArrayList<AssignmentGradeRecord>();
		List<Comment> comments = Arrays.asList(new Comment[] {new Comment(STUDENT_IN_SECTION_UID1, "First comment", assignment)});
		gradebookManager.updateAssignmentGradesAndComments(assignment, gradeRecords, comments);

		// Make sure we don't get a comment for the student who doesn't have one.
		CommentDefinition commentDefinition = gradebookService.getAssignmentScoreComment(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_NOT_IN_SECTION_UID1);
		Assert.assertTrue(commentDefinition == null);
		CommentDefinition commentDefById = gradebookService.getAssignmentScoreComment(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_NOT_IN_SECTION_UID1);
		Assert.assertTrue(commentDefById == null);

		// Make sure we can retrieve the comment.
		commentDefinition = gradebookService.getAssignmentScoreComment(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(commentDefinition.getAssignmentName().equals(ASN_TITLE1));
		Assert.assertTrue(commentDefinition.getCommentText().equals("First comment"));
		Assert.assertTrue(commentDefinition.getGraderUid().equals(INSTRUCTOR_UID));
		Assert.assertTrue(commentDefinition.getStudentUid().equals(STUDENT_IN_SECTION_UID1));

		// Now change the comment.
		setAuthnId(TA_UID);
		gradebookService.setAssignmentScoreComment(GRADEBOOK_UID_NO_CAT, ASN_TITLE1, STUDENT_IN_SECTION_UID1, "Second comment");
		commentDefinition = gradebookService.getAssignmentScoreComment(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(commentDefinition.getCommentText().equals("Second comment"));
		Assert.assertTrue(commentDefinition.getGraderUid().equals(TA_UID));
	}

	public void testPermissionChecks() throws Exception {
		// test the instructor
		setAuthnId(INSTRUCTOR_UID);
		Assert.assertTrue(gradebookService.currentUserHasGradeAllPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertTrue(gradebookService.currentUserHasEditPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertTrue(gradebookService.currentUserHasGradingPerm(GRADEBOOK_UID_NO_CAT));

		// test the TA
		setAuthnId(TA_UID);
		Assert.assertTrue(gradebookService.currentUserHasGradingPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertFalse(gradebookService.currentUserHasGradeAllPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertFalse(gradebookService.currentUserHasEditPerm(GRADEBOOK_UID_NO_CAT));

		// test the student
		setAuthnId(STUDENT_IN_SECTION_UID1);
		Assert.assertTrue(gradebookService.currentUserHasViewOwnGradesPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertFalse(gradebookService.currentUserHasEditPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertFalse(gradebookService.currentUserHasGradingPerm(GRADEBOOK_UID_NO_CAT));
		Assert.assertFalse(gradebookService.currentUserHasGradeAllPerm(GRADEBOOK_UID_NO_CAT));
	}

	public void testGradableObjectDefined() throws Exception {
		Assert.assertFalse(gradebookService.isGradableObjectDefined(new Long(15)));
		Assert.assertTrue(gradebookService.isGradableObjectDefined(asn1IdNoCat));
		
		try {
			gradebookService.isGradableObjectDefined(null);
			log.error("isGradableObjectDefined did not catch null gbObjectId");
			Assert.fail();
		} catch (IllegalArgumentException e) {
		}
	}
	
	public void testGetViewableAssignmentsForCurrentUser() throws Exception {
		// first test gb without grader permissions
		// test instructor 
		setAuthnId(INSTRUCTOR_UID);
		List viewableAssignments = gradebookService.getViewableAssignmentsForCurrentUser(GRADEBOOK_UID_NO_CAT);
		Assert.assertTrue(viewableAssignments.size() == 2);
		
		// ta 
		setAuthnId(TA_UID);
		log.info("1-----------");
		viewableAssignments = gradebookService.getViewableAssignmentsForCurrentUser(GRADEBOOK_UID_NO_CAT);
		log.info("2----------: " + viewableAssignments.size());
		Assert.assertTrue(viewableAssignments.size() == 2);

		
		// student
		setAuthnId(STUDENT_IN_SECTION_UID1);
		// only returns released items
		viewableAssignments = gradebookService.getViewableAssignmentsForCurrentUser(GRADEBOOK_UID_NO_CAT);
		Assert.assertTrue(viewableAssignments.size() == 0);
		
		// now test gb with categories and grader permissions
		Gradebook gb = gradebookManager.getGradebook(GRADEBOOK_UID_WITH_CAT);
		// ta may only grade one category, so only 1 assignment
		gradebookManager.addPermission(gb.getId(), TA_UID, GradebookService.gradePermission, cat1Id, section2Uid);
		
		setAuthnId(INSTRUCTOR_UID);
		viewableAssignments = gradebookService.getViewableAssignmentsForCurrentUser(GRADEBOOK_UID_WITH_CAT);
		Assert.assertTrue(viewableAssignments.size() == 2);
		
		setAuthnId(TA_UID);
		viewableAssignments = gradebookService.getViewableAssignmentsForCurrentUser(GRADEBOOK_UID_WITH_CAT);
		Assert.assertTrue(viewableAssignments.size() == 1);
		
		setAuthnId(STUDENT_IN_SECTION_UID2);
		// only returns released assign
		viewableAssignments = gradebookService.getViewableAssignmentsForCurrentUser(GRADEBOOK_UID_WITH_CAT);
		Assert.assertTrue(viewableAssignments.size() == 0);
	}
	
	public void testGetViewableSectionUuidToNameMap() throws Exception {
		setAuthnId(INSTRUCTOR_UID);
		Map sectionUuidNameMap = gradebookService.getViewableSectionUuidToNameMap(GRADEBOOK_UID_NO_CAT);
		Assert.assertTrue(sectionUuidNameMap.size() == 1);
		
		setAuthnId(TA_UID);
		sectionUuidNameMap = gradebookService.getViewableSectionUuidToNameMap(GRADEBOOK_UID_NO_CAT);
		Assert.assertTrue(sectionUuidNameMap.size() == 1);
		
		setAuthnId(TA_NO_SECT_UID);
		sectionUuidNameMap = gradebookService.getViewableSectionUuidToNameMap(GRADEBOOK_UID_NO_CAT);
		Assert.assertTrue(sectionUuidNameMap.size() == 0);
		
		setAuthnId(STUDENT_IN_SECTION_UID1);
		sectionUuidNameMap = gradebookService.getViewableSectionUuidToNameMap(GRADEBOOK_UID_NO_CAT);
		Assert.assertTrue(sectionUuidNameMap.size() == 0);
		
		// now double check with grader permissions
		// now test gb with categories and grader permissions
		Gradebook gb = gradebookManager.getGradebook(GRADEBOOK_UID_WITH_CAT);
		// this ta is not a member of a section, but grader perms will allow viewing section
		gradebookManager.addPermission(gb.getId(), TA_NO_SECT_UID, GradebookService.gradePermission, null, section2Uid);
		setAuthnId(TA_NO_SECT_UID);
		sectionUuidNameMap = gradebookService.getViewableSectionUuidToNameMap(GRADEBOOK_UID_WITH_CAT);
		Assert.assertTrue(sectionUuidNameMap.size() == 1);
		
	}
	
	public void testGetViewableStudentsForItemForCurrentUser() throws Exception {
		// testing w/o grader permissions
		setAuthnId(INSTRUCTOR_UID);
		Map viewableStudentsMap = gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
		Assert.assertEquals(2, viewableStudentsMap.size());
		for (Iterator stIter = viewableStudentsMap.keySet().iterator(); stIter.hasNext();) {
			String studentId = (String) stIter.next();
			Assert.assertEquals(GradebookService.gradePermission, (String)viewableStudentsMap.get(studentId));
		}
		
		setAuthnId(TA_NO_SECT_UID);
		viewableStudentsMap = gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
		Assert.assertTrue(viewableStudentsMap.size() == 0);
		
		setAuthnId(TA_UID);
		viewableStudentsMap = gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
		Assert.assertTrue(viewableStudentsMap.size() == 1);
		Assert.assertEquals(GradebookService.gradePermission, (String)viewableStudentsMap.get(STUDENT_IN_SECTION_UID1));
		
		// now test w/ grader perms
		Gradebook gb = gradebookManager.getGradebook(GRADEBOOK_UID_WITH_CAT);
		// this ta is not a member of a section, but grader perms will allow viewing section
		gradebookManager.addPermission(gb.getId(), TA_NO_SECT_UID, GradebookService.viewPermission, null, section2Uid);
		
		setAuthnId(TA_NO_SECT_UID);
		viewableStudentsMap = gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_WITH_CAT, asn1IdWithCat);
		Assert.assertTrue(viewableStudentsMap.size() == 1);
		Assert.assertEquals(GradebookService.viewPermission, (String)viewableStudentsMap.get(STUDENT_IN_SECTION_UID2));
		
		// make sure the student gets no students
		setAuthnId(STUDENT_IN_SECTION_UID1);
		viewableStudentsMap = gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_WITH_CAT, asn1IdWithCat);
        Assert.assertEquals(0, viewableStudentsMap.size());
        
		
	}
	
	public void testGetViewableStudentsForItemForUser() throws Exception {
        // testing w/o grader permissions
        Map viewableStudentsMap = gradebookService.getViewableStudentsForItemForUser(INSTRUCTOR_UID, GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
        Assert.assertEquals(2, viewableStudentsMap.size());
        for (Iterator stIter = viewableStudentsMap.keySet().iterator(); stIter.hasNext();) {
            String studentId = (String) stIter.next();
            Assert.assertEquals(GradebookService.gradePermission, (String)viewableStudentsMap.get(studentId));
        }
        
        viewableStudentsMap = gradebookService.getViewableStudentsForItemForUser(TA_NO_SECT_UID, GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
        Assert.assertEquals(0, viewableStudentsMap.size());

        viewableStudentsMap = gradebookService.getViewableStudentsForItemForUser(TA_UID, GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
        Assert.assertEquals(1, viewableStudentsMap.size());
        Assert.assertEquals(GradebookService.gradePermission, (String)viewableStudentsMap.get(STUDENT_IN_SECTION_UID1));
        
        // now test w/ grader perms
        Gradebook gb = gradebookManager.getGradebook(GRADEBOOK_UID_WITH_CAT);
        // this ta is not a member of a section, but grader perms will allow viewing section
        gradebookManager.addPermission(gb.getId(), TA_NO_SECT_UID, GradebookService.viewPermission, null, section2Uid);

        viewableStudentsMap = gradebookService.getViewableStudentsForItemForUser(TA_NO_SECT_UID, GRADEBOOK_UID_WITH_CAT, asn1IdWithCat);
        Assert.assertEquals(1, viewableStudentsMap.size());
        Assert.assertEquals(GradebookService.viewPermission, (String)viewableStudentsMap.get(STUDENT_IN_SECTION_UID2));
        
        // make sure student has no students returned
        viewableStudentsMap = gradebookService.getViewableStudentsForItemForUser(STUDENT_IN_SECTION_UID1, GRADEBOOK_UID_WITH_CAT, asn1IdWithCat);
        Assert.assertEquals(0, viewableStudentsMap.size());
    }
	
	public void testGetGradesForStudentsForItem() throws Exception {
		setAuthnId(INSTRUCTOR_UID);
		Map studentIdFunctionMap = 
			gradebookService.getViewableStudentsForItemForCurrentUser(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
		List studentIds = new ArrayList(studentIdFunctionMap.keySet());
		
		List gradeDefs = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentIds);
		Assert.assertNotNull(gradeDefs);
		Assert.assertTrue(gradeDefs.size() == 0);
		
		// add a score to the gb
		gradebookService.setAssignmentScoreString(GRADEBOOK_UID_NO_CAT, ASN_TITLE1, STUDENT_IN_SECTION_UID1, new String("35"), "Service Test");
		gradeDefs = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentIds);
		Assert.assertEquals(1, gradeDefs.size());
		GradeDefinition gradeForS1 = (GradeDefinition)gradeDefs.get(0);
		Assert.assertTrue(gradeForS1 != null);
		Assert.assertEquals(GradebookService.GRADE_TYPE_POINTS, gradeForS1.getGradeEntryType());
		Assert.assertEquals(STUDENT_IN_SECTION_UID1, gradeForS1.getStudentUid());
		Assert.assertTrue(gradeForS1.isGradeReleased() == false);
		Assert.assertEquals("35.0", gradeForS1.getGrade());
		Assert.assertEquals(INSTRUCTOR_UID, gradeForS1.getGraderUid());
		Assert.assertNotNull(gradeForS1.getDateRecorded());
		
		// add another score to gb
		gradebookService.setAssignmentScoreString(GRADEBOOK_UID_NO_CAT, ASN_TITLE1, STUDENT_NOT_IN_SECTION_UID1, new String("40"), "Service Test");
		gradeDefs = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentIds);
		Assert.assertTrue(gradeDefs.size() == 2);
		
		setAuthnId(TA_UID);
		//should throw SecurityException b/c trying to get one student that user
		// is not authorized to view
		try {
			gradeDefs = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentIds);
			Assert.fail();
		} catch (SecurityException e) {
			
		}
		
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_PERCENTAGE);
		
		// try with the auth students
		List studentInSection = new ArrayList();
		studentInSection.add(STUDENT_IN_SECTION_UID1);
		gradeDefs = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentInSection);
		Assert.assertTrue(gradeDefs.size() == 1);
		gradeForS1 = (GradeDefinition)gradeDefs.get(0);
		Assert.assertTrue(gradeForS1 != null);
		Assert.assertEquals(GradebookService.GRADE_TYPE_PERCENTAGE, gradeForS1.getGradeEntryType());
		Assert.assertEquals(STUDENT_IN_SECTION_UID1, gradeForS1.getStudentUid());
		Assert.assertTrue(gradeForS1.isGradeReleased() == false);
		Assert.assertEquals("87.5", gradeForS1.getGrade());
		Assert.assertEquals(INSTRUCTOR_UID, gradeForS1.getGraderUid());
		Assert.assertNotNull(gradeForS1.getDateRecorded());
		
		gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_LETTER);
		gradeDefs = gradebookService.getGradesForStudentsForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, studentInSection);
		Assert.assertTrue(gradeDefs.size() == 1);
		gradeForS1 = (GradeDefinition)gradeDefs.get(0);
		Assert.assertEquals(GradebookService.GRADE_TYPE_LETTER, gradeForS1.getGradeEntryType());
		Assert.assertEquals("B+", gradeForS1.getGrade());

	}
	
	public void testGetAssignment() throws Exception {
		setAuthnId(INSTRUCTOR_UID);
		Assignment assnDef = gradebookService.getAssignment(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
		Assert.assertNotNull(assnDef);
		Assert.assertEquals(ASN_TITLE1, assnDef.getName());
		Assert.assertEquals(new Double(40), assnDef.getPoints()); 
		
		try {
			assnDef = gradebookService.getAssignment(GRADEBOOK_UID_NO_CAT, new Long(-1));
			Assert.fail();
		} catch (AssessmentNotFoundException anfe) {
			
		}
		
	}
	
	public void testIsGradeValid() throws Exception {
		// try a null gradebookUuid
		try {
			gradebookService.isGradeValid(null, null);
			fail("did not catch null gradebookUuid passed to isGradeValid");
		} catch (IllegalArgumentException iae) {}
		
		// let's start with a points-based gradebook
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_POINTS);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		// null grades are valid
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, null));
		// try some positive point values
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "25.34"));
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "0"));
		// negative should fail
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "-1"));
		// more than 2 decimal places should fail
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "10.125"));
		// try non-numeric
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "A"));
		
		// switch to %-based gradebook
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_PERCENTAGE);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		// null grades are valid
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, null));
		// try some positive point values
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "25.34"));
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "0"));
		// negative should fail
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "-1"));
		// more than 2 decimal places should fail
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "10.125"));
		// try non-numeric
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "A"));
		
		// switch to letter-based gradebook
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_LETTER);
		gradebookManager.updateGradebook(gradebookNoCat);
		// null grades are valid
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, null));
		// try some point values
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "25.34"));
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "0"));
		// negative should fail
		assertFalse(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "-1"));
		// try some valid ones
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "A"));
		assertTrue(gradebookService.isGradeValid(GRADEBOOK_UID_NO_CAT, "c-"));
	}
	
	public void testIdentifyStudentsWithInvalidGrades() throws Exception {
		// try some null parameters
		try {
			gradebookService.identifyStudentsWithInvalidGrades(null, new HashMap<String, String>());
			fail("did not catch null gradebookUid passed to identifyStudentsWithInvalidGrades");
		} catch (IllegalArgumentException iae) {}
		
		// try a null map 
		List<String> invalidStudentIds = gradebookService.identifyStudentsWithInvalidGrades(GRADEBOOK_UID_NO_CAT, null);
		assertTrue(invalidStudentIds.isEmpty());
		
		//add some students and grades for a points-based gb
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_POINTS);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		Map<String, String> studentIdGradeMap = new HashMap<String, String>();
		studentIdGradeMap.put(STUDENT_IN_SECTION_UID1, "15");
		studentIdGradeMap.put(STUDENT_IN_SECTION_UID2, "-1");  // invalid
		studentIdGradeMap.put(STUDENT_NOT_IN_SECTION_UID1, "A"); //invalid
		studentIdGradeMap.put(STUDENT_NOT_IN_SECTION_UID2, "25.67"); //valid//
		
		invalidStudentIds = gradebookService.identifyStudentsWithInvalidGrades(GRADEBOOK_UID_NO_CAT, studentIdGradeMap);
		assertEquals(2, invalidStudentIds.size());
		assertTrue(invalidStudentIds.contains(STUDENT_IN_SECTION_UID2));
		assertTrue(invalidStudentIds.contains(STUDENT_NOT_IN_SECTION_UID1));
		
		//use a %-based gradebook
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_PERCENTAGE);
		gradebookManager.updateGradebook(gradebookNoCat);
		invalidStudentIds = gradebookService.identifyStudentsWithInvalidGrades(GRADEBOOK_UID_NO_CAT, studentIdGradeMap);
		assertEquals(2, invalidStudentIds.size());
		assertTrue(invalidStudentIds.contains(STUDENT_IN_SECTION_UID2));
		assertTrue(invalidStudentIds.contains(STUDENT_NOT_IN_SECTION_UID1));
		
		// use a letter-based gb
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_LETTER);
		gradebookManager.updateGradebook(gradebookNoCat);
		invalidStudentIds = gradebookService.identifyStudentsWithInvalidGrades(GRADEBOOK_UID_NO_CAT, studentIdGradeMap);
		assertEquals(3, invalidStudentIds.size());
		assertTrue(invalidStudentIds.contains(STUDENT_IN_SECTION_UID1));
		assertTrue(invalidStudentIds.contains(STUDENT_IN_SECTION_UID2));
		assertTrue(invalidStudentIds.contains(STUDENT_NOT_IN_SECTION_UID2));
	}
	
	public void testSaveGradeAndCommentForStudent() throws Exception {
		// try some null params
		try {
			gradebookService.saveGradeAndCommentForStudent(null, new Long(1), STUDENT_IN_SECTION_UID1, "A", "Good work");
			fail("Did not catch null gradebookUuid passed to saveGradeAndCommentForStudent");
		} catch (IllegalArgumentException iae) {}
		
		try {
			gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, null, STUDENT_IN_SECTION_UID1, "A", "Good work");
			fail("Did not catch null gradableObjectId passed to saveGradeAndCommentForStudent");
		} catch (IllegalArgumentException iae) {}
		
		try {
			gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, new Long(1), null, "A", "Good work");
			fail("Did not catch null gradableObjectId passed to saveGradeAndCommentForStudent");
		} catch (IllegalArgumentException iae) {}
		
		// try invalid gradebookUuid
		try {
			gradebookService.saveGradeAndCommentForStudent("bogus!", asn1IdNoCat, STUDENT_IN_SECTION_UID1, null, null);
			fail("did not catch bogus gradebookUuid passed to saveGradeAndCommentForStudent");
		} catch (GradebookNotFoundException gnfe) {}
		
		// try invalid gradableObjectId
		try {
			gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, new Long(12345), STUDENT_IN_SECTION_UID1, null, null);
			fail("did not catch bogus gradableObjectId passed to saveGradeAndCommentForStudent");
		} catch (AssessmentNotFoundException anfe) {}
		
		// use point-based gb
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_POINTS);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		// add a grade and comment for student
		String score = "15.0";
		String comment = "Good work";
		gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1, score, comment);
		
		// try to retrieve it again
		GradeDefinition gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertEquals(score, gradeDef.getGrade());
		assertEquals(comment, gradeDef.getGradeComment());
		
		// try an invalid grade
		try {
			gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1, "A", comment);
			fail("did not catch invalid grade passed to saveGradeAndCommentForStudent");
		} catch (InvalidGradeException ige) {}
		
		// try setting the score and comment to null
		score = null;
		comment = null;
		
		gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1, score, comment);
		
		// try to retrieve it again
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertNull(gradeDef.getGrade());
		assertNull(gradeDef.getGradeComment());
		
		// set just a comment
		comment = "Try again!";
		gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1, score, comment);
		
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertNull(gradeDef.getGrade());
		assertEquals(comment, gradeDef.getGradeComment());
		
		// try to update a student as a TA
		authn.setAuthnContext(TA_UID);
		// should only have auth to update student in her section
		score = "25.78";
		comment = "Jolly good show";
		
		gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1, score, comment);
		
		// try to retrieve it again
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertEquals(score, gradeDef.getGrade());
		assertEquals(comment, gradeDef.getGradeComment());
		
		// now try to update a student not in the section
		try {
			gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_NOT_IN_SECTION_UID1, score, comment);
			fail("did not catch ta trying to update score and comment w/o authorization!");
		} catch (SecurityException se) {}
		
		// make sure students don't have authorization
		authn.setAuthnContext(STUDENT_IN_SECTION_UID1);
		try {
			gradebookService.saveGradeAndCommentForStudent(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_NOT_IN_SECTION_UID1, score, comment);
			fail("did not catch student trying to update score and comment w/o authorization!");
		} catch (SecurityException se) {}
	}
	
	public void testSaveGradesAndComments() throws Exception {
		// try nulls
		try {
			gradebookService.saveGradesAndComments(null, asn1IdNoCat, new ArrayList<GradeDefinition>());
			fail("did not catch null gradebookUuid passed to saveGradesAndComments");
		} catch (IllegalArgumentException iae) {}
		
		try {
			gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, null, new ArrayList<GradeDefinition>());
			fail("did not catch null gradableObjectId passed to saveGradesAndComments");
		} catch (IllegalArgumentException iae) {}
		
		// try invalid gradebookUuid
		try {
			gradebookService.saveGradesAndComments("bogus!", asn1IdNoCat, new ArrayList<GradeDefinition>());
			fail("did not catch bogus gradebookUuid passed to saveGradesAndComments");
		} catch (GradebookNotFoundException gnfe) {}
		
		// try invalid gradableObjectId
		try {
			gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, new Long(12345), new ArrayList<GradeDefinition>());
			fail("did not catch bogus gradableObjectId passed to saveGradesAndComments");
		} catch (AssessmentNotFoundException anfe) {}
		
		authn.setAuthnContext(INSTRUCTOR_UID);
		
		// null gradeDef list shouldn't do anything
		gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, null);
		
		// Add some grade defs
		String def1Grade = "10.5";
		String def1Comment = "Good work";
		String def2Grade = "";
		String def2Comment = "Turn this in";

		GradeDefinition def1 = new GradeDefinition();
		def1.setStudentUid(STUDENT_IN_SECTION_UID1);
		def1.setGrade(def1Grade);
		def1.setGradeComment(def1Comment);
		
		GradeDefinition def2 = new GradeDefinition();
		def2.setStudentUid(STUDENT_NOT_IN_SECTION_UID1);
		def2.setGrade(def2Grade);
		def2.setGradeComment(def2Comment);
		
		List<GradeDefinition> gradeDefList = new ArrayList<GradeDefinition>();
		gradeDefList.add(def1);
		gradeDefList.add(def2);
		
		// use point-based gb
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_POINTS);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, gradeDefList);
		
		// now let's see if the change was successful
		// try to retrieve it again
		GradeDefinition gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertEquals(def1Grade, gradeDef.getGrade());
		assertEquals(def1Comment, gradeDef.getGradeComment());
		
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_NOT_IN_SECTION_UID1);
		assertNull(gradeDef.getGrade());
		assertEquals(def2Comment, gradeDef.getGradeComment());
		
		// let's try this as a TA - should throw SecurityException b/c not auth for STUDENT_NOT_IN_SECTION_UID1
		authn.setAuthnContext(TA_UID);
		try {
			gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, gradeDefList);
			fail("did not catch TA trying to save grades for students w/o auth");
		} catch (SecurityException se) {}
		
		// if we remove def2, TA should be able to update
		gradeDefList = new ArrayList<GradeDefinition>();		
		def1Grade = "37.0";
		def1Comment = "";
		def1.setGrade(def1Grade);
		def1.setGradeComment(def1Comment);
		gradeDefList.add(def1);
		
		gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, gradeDefList);
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertEquals(def1Grade, gradeDef.getGrade());
		assertEquals(def1Comment, gradeDef.getGradeComment());
		
		// let's try an invalid grade
		gradeDefList = new ArrayList<GradeDefinition>();		
		def1.setGrade("A");
		def1.setGradeComment("I like letters");
		gradeDefList.add(def1);
		
		try {
			gradebookService.saveGradesAndComments(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, gradeDefList);
			fail("Did not catch invalid grade passed to saveGradesAndComments");
		} catch (InvalidGradeException ige) {}
		
		// double check grade wasn't updated
		gradeDef = gradebookService.getGradeDefinitionForStudentForItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat, STUDENT_IN_SECTION_UID1);
		assertEquals(def1Grade, gradeDef.getGrade());
		assertEquals(def1Comment, gradeDef.getGradeComment());
	}
	
	public void testGetGradeEntryType() throws Exception {
		// try passing a null gradebookUid
		try {
			gradebookService.getGradeEntryType(null);
			fail("did not catch null gradebookUid passed to getGradeEntryType");
		} catch (IllegalArgumentException iae) {}
		
		// try a bogus gradebookUid
		try {
			gradebookService.getGradeEntryType("bogus");
			fail("did not catch gradebook that didn't exist");
		} catch (GradebookNotFoundException gnfe) {}
		
		// let's start with a point gb
		Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_POINTS);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		assertEquals(GradebookService.GRADE_TYPE_POINTS, gradebookService.getGradeEntryType(GRADEBOOK_UID_NO_CAT));
		
		// change it to %
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_PERCENTAGE);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		assertEquals(GradebookService.GRADE_TYPE_PERCENTAGE, gradebookService.getGradeEntryType(GRADEBOOK_UID_NO_CAT));
		
		// change it to letter
		gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_LETTER);
		gradebookManager.updateGradebook(gradebookNoCat);
		
		assertEquals(GradebookService.GRADE_TYPE_LETTER, gradebookService.getGradeEntryType(GRADEBOOK_UID_NO_CAT));
	}
	
	public void testGetLowestPossibleGradeForGbItem() throws Exception {
	    // try passing some nulls
	    try {
	        gradebookService.getLowestPossibleGradeForGbItem(null, asn1IdNoCat);
	        fail("did not catch null gradebookUid passed to getLowestPossibleGradeForGbItem");
	    } catch (IllegalArgumentException iae) {}

	    try {
	        gradebookService.getLowestPossibleGradeForGbItem(GRADEBOOK_UID_NO_CAT, null);
	        fail("did not catch null gradebookItemId passed to getLowestPossibleGradeForGbItem");
	    } catch (IllegalArgumentException iae) {}

	    // let's start with a point gb
	    Gradebook gradebookNoCat = gradebookManager.getGradebook(GRADEBOOK_UID_NO_CAT);
	    gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_POINTS);
	    gradebookManager.updateGradebook(gradebookNoCat);
	    String lowestPointsPossible = gradebookService.getLowestPossibleGradeForGbItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
	    assertEquals("0", lowestPointsPossible);

	    // change it to %
	    gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_PERCENTAGE);
	    gradebookManager.updateGradebook(gradebookNoCat);

	    lowestPointsPossible = gradebookService.getLowestPossibleGradeForGbItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
	    assertEquals("0", lowestPointsPossible);

	    // change it to letter
	    gradebookNoCat.setGrade_type(GradebookService.GRADE_TYPE_LETTER);
	    gradebookManager.updateGradebook(gradebookNoCat);

	    lowestPointsPossible = gradebookService.getLowestPossibleGradeForGbItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
	    assertEquals("F", lowestPointsPossible);

	    // now let's change the gb item to ungraded
	    org.sakaiproject.tool.gradebook.Assignment assignment = gradebookManager.getAssignment(asn1IdNoCat);
	    assignment.setUngraded(true);
	    gradebookManager.updateAssignment(assignment);

	    lowestPointsPossible = gradebookService.getLowestPossibleGradeForGbItem(GRADEBOOK_UID_NO_CAT, asn1IdNoCat);
	    assertNull(lowestPointsPossible);
	}
	
	public void testGetCategoryDefinitions() throws Exception {
	    try {
	        gradebookService.getCategoryDefinitions(null);
	        fail("Did not catch null gradebookUid passed to getCategoryDefinitions");
	    } catch (IllegalArgumentException iae) {}
	    
	    authn.setAuthnContext(STUDENT_IN_SECTION_UID1);
	    try {
	        gradebookService.getCategoryDefinitions(GRADEBOOK_UID_WITH_CAT);
            fail("Did not catch student accessing category information");
        } catch (SecurityException se) {}
        
        authn.setAuthnContext(INSTRUCTOR_UID);
        List<CategoryDefinition> catDefs = gradebookService.getCategoryDefinitions(GRADEBOOK_UID_WITH_CAT);
        assertEquals(2, catDefs.size());
        for (CategoryDefinition def : catDefs) {
            if (def.getId().equals(cat1Id)) {
                assertEquals(CAT1_NAME, def.getName());
                assertEquals(0D, def.getWeight());
            } else if (def.getId().equals(cat2Id)) {
                assertEquals(CAT2_NAME, def.getName());
                assertEquals(0D, def.getWeight());
            } else {
                fail("Unknown category returned by getCategoryDefs");
            }
        }
        
        // now try a gradebook w/o categories
        catDefs = gradebookService.getCategoryDefinitions(GRADEBOOK_UID_NO_CAT);
        assertEquals(0, catDefs.size());
	}
	
	public void testIsPointsPossibleValid() throws Exception {
	    // try some null values
	    try {
	        gradebookService.isPointsPossibleValid(null, new Assignment(), 5D);
	        fail("Did not catch null gradebookUid passed to isPointsPossibleValid");
	    } catch (IllegalArgumentException iae) {}
	    
	    try {
            gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, null, 5D);
            fail("Did not catch null gradebookItem passed to isPointsPossibleValid");
        } catch (IllegalArgumentException iae) {}
        
        // try passing a null points possible
        assertEquals(GradebookService.PointsPossibleValidation.INVALID_NULL_VALUE, gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, new Assignment(), null));
        // try a negative
        assertEquals(GradebookService.PointsPossibleValidation.INVALID_NUMERIC_VALUE, gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, new Assignment(), -5D));
        // try 0
        assertEquals(GradebookService.PointsPossibleValidation.INVALID_NUMERIC_VALUE, gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, new Assignment(), 0D));
        // try more than 2 decimal places
        assertEquals(GradebookService.PointsPossibleValidation.INVALID_DECIMAL, gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, new Assignment(), 5.123D));
        // try some valid points possible
        assertEquals(GradebookService.PointsPossibleValidation.VALID, gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, new Assignment(), 0.01D));
        assertEquals(GradebookService.PointsPossibleValidation.VALID,gradebookService.isPointsPossibleValid(GRADEBOOK_UID_NO_CAT, new Assignment(), 100D));

	}
	
}