001: /**********************************************************************************
002: *
003: * $Id: GradableObjectManagerTest.java 20345 2007-01-16 20:25:32Z ray@media.berkeley.edu $
004: *
005: ***********************************************************************************
006: *
007: * Copyright (c) 2005 The Regents of the University of California, The MIT Corporation
008: *
009: * Licensed under the Educational Community License, Version 1.0 (the "License");
010: * you may not use this file except in compliance with the License.
011: * You may obtain a copy of the License at
012: *
013: * http://www.opensource.org/licenses/ecl1.php
014: *
015: * Unless required by applicable law or agreed to in writing, software
016: * distributed under the License is distributed on an "AS IS" BASIS,
017: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
018: * See the License for the specific language governing permissions and
019: * limitations under the License.
020: *
021: **********************************************************************************/package org.sakaiproject.tool.gradebook.test;
022:
023: import java.util.ArrayList;
024: import java.util.Arrays;
025: import java.util.Collection;
026: import java.util.Date;
027: import java.util.HashSet;
028: import java.util.Iterator;
029: import java.util.List;
030: import java.util.Set;
031:
032: import junit.framework.Assert;
033:
034: import org.sakaiproject.service.gradebook.shared.ConflictingAssignmentNameException;
035: import org.sakaiproject.tool.gradebook.AbstractGradeRecord;
036: import org.sakaiproject.tool.gradebook.Assignment;
037: import org.sakaiproject.tool.gradebook.AssignmentGradeRecord;
038: import org.sakaiproject.tool.gradebook.CourseGrade;
039: import org.sakaiproject.tool.gradebook.Gradebook;
040:
041: /**
042: */
043: public class GradableObjectManagerTest extends GradebookTestBase {
044: protected static final String ASN1_NAME = "Assignment #1";
045: protected static final String ASN2_NAME = "Assignment #2";
046: protected static final String ASN3_NAME = "Assignment #3";
047:
048: protected Gradebook gradebook;
049:
050: protected void onSetUpInTransaction() throws Exception {
051: super .onSetUpInTransaction();
052:
053: // Create a gradebook to work with
054: String className = this .getClass().getName();
055: String gradebookName = className + (new Date()).getTime();
056: gradebookFrameworkService.addGradebook(gradebookName,
057: gradebookName);
058:
059: // Set up a holder for enrollments, teaching assignments, and sections.
060: integrationSupport.createCourse(gradebookName, gradebookName,
061: false, false, false);
062:
063: // Grab the gradebook for use in the tests
064: gradebook = gradebookManager.getGradebook(gradebookName);
065: }
066:
067: public void testCreateAndUpdateAssignment() throws Exception {
068: Long asnId = gradebookManager.createAssignment(gradebook
069: .getId(), ASN1_NAME, new Double(10), new Date(),
070: Boolean.FALSE, Boolean.FALSE);
071: Assignment asn = gradebookManager.getAssignment(asnId);
072: asn.setPointsPossible(new Double(20));
073: gradebookManager.updateAssignment(asn);
074:
075: // Fetch the updated assignment with statistics
076: Assignment persistentAssignment = gradebookManager
077: .getAssignmentWithStats(asnId);
078: // Ensure the DB update was successful
079: Assert.assertEquals(persistentAssignment.getPointsPossible(),
080: new Double(20));
081:
082: // Try to save a new assignment with the same name
083: boolean errorThrown = false;
084: try {
085: gradebookManager.createAssignment(gradebook.getId(),
086: ASN1_NAME, new Double(20), new Date(),
087: Boolean.FALSE, Boolean.FALSE);
088: } catch (ConflictingAssignmentNameException e) {
089: errorThrown = true;
090: }
091: Assert.assertTrue(errorThrown);
092:
093: // Save a second assignment
094: Long secondId = gradebookManager.createAssignment(gradebook
095: .getId(), ASN2_NAME, new Double(10), new Date(),
096: Boolean.FALSE, Boolean.FALSE);
097: Assignment asn2 = gradebookManager.getAssignment(secondId);
098:
099: errorThrown = false;
100:
101: // Try to update its name to that of the first
102: asn2.setName(ASN1_NAME);
103: try {
104: gradebookManager.updateAssignment(asn2);
105: } catch (ConflictingAssignmentNameException e) {
106: errorThrown = true;
107: }
108: Assert.assertTrue(errorThrown);
109: }
110:
111: public void testGradableObjectSorting() throws Exception {
112: // Create an assignment with a null date
113: Long id1 = gradebookManager.createAssignment(gradebook.getId(),
114: ASN1_NAME, new Double(10), null, Boolean.FALSE,
115: Boolean.FALSE);
116:
117: // Create an assignment with an early date (in 1970)
118: Long id2 = gradebookManager.createAssignment(gradebook.getId(),
119: ASN2_NAME, new Double(20), new Date(10), Boolean.FALSE,
120: Boolean.FALSE);
121:
122: // Create an assignment with a date of now
123: Long id3 = gradebookManager.createAssignment(gradebook.getId(),
124: ASN3_NAME, new Double(30), new Date(), Boolean.FALSE,
125: Boolean.FALSE);
126:
127: // Get lists of assignments with different sort orders
128: List ascDateOrderedAssignments = gradebookManager
129: .getAssignments(gradebook.getId(),
130: Assignment.SORT_BY_DATE, true);
131: List descDateOrderedAssignments = gradebookManager
132: .getAssignments(gradebook.getId(),
133: Assignment.SORT_BY_DATE, false);
134:
135: List ascNameOrderedAssignments = gradebookManager
136: .getAssignments(gradebook.getId(),
137: Assignment.SORT_BY_NAME, true);
138: List descNameOrderedAssignments = gradebookManager
139: .getAssignments(gradebook.getId(),
140: Assignment.SORT_BY_NAME, false);
141:
142: List ascPointsOrderedAssignments = gradebookManager
143: .getAssignments(gradebook.getId(),
144: Assignment.SORT_BY_POINTS, true);
145: List descPointsOrderedAssignments = gradebookManager
146: .getAssignments(gradebook.getId(),
147: Assignment.SORT_BY_POINTS, false);
148:
149: Assignment asn1 = gradebookManager.getAssignment(id1);
150: Assignment asn2 = gradebookManager.getAssignment(id2);
151: Assignment asn3 = gradebookManager.getAssignment(id3);
152:
153: // Ensure that the dates sort correctly
154: Assert
155: .assertTrue(ascDateOrderedAssignments.indexOf(asn2) < ascDateOrderedAssignments
156: .indexOf(asn3));
157: Assert
158: .assertTrue(ascDateOrderedAssignments.indexOf(asn3) < ascDateOrderedAssignments
159: .indexOf(asn1));
160: Assert
161: .assertTrue(descDateOrderedAssignments.indexOf(asn2) > descDateOrderedAssignments
162: .indexOf(asn3));
163: Assert
164: .assertTrue(descDateOrderedAssignments.indexOf(asn3) > descDateOrderedAssignments
165: .indexOf(asn1));
166:
167: // Ensure that the names sort correctly
168: Assert
169: .assertTrue(ascNameOrderedAssignments.indexOf(asn1) < ascNameOrderedAssignments
170: .indexOf(asn2));
171: Assert
172: .assertTrue(ascNameOrderedAssignments.indexOf(asn2) < ascNameOrderedAssignments
173: .indexOf(asn3));
174: Assert
175: .assertTrue(descNameOrderedAssignments.indexOf(asn1) > descNameOrderedAssignments
176: .indexOf(asn2));
177: Assert
178: .assertTrue(descNameOrderedAssignments.indexOf(asn2) > descNameOrderedAssignments
179: .indexOf(asn3));
180:
181: // Ensure that the points sort correctly
182: Assert
183: .assertTrue(ascPointsOrderedAssignments.indexOf(asn1) < ascPointsOrderedAssignments
184: .indexOf(asn2));
185: Assert
186: .assertTrue(ascPointsOrderedAssignments.indexOf(asn2) < ascPointsOrderedAssignments
187: .indexOf(asn3));
188: Assert
189: .assertTrue(descPointsOrderedAssignments.indexOf(asn1) > descPointsOrderedAssignments
190: .indexOf(asn2));
191: Assert
192: .assertTrue(descPointsOrderedAssignments.indexOf(asn2) > descPointsOrderedAssignments
193: .indexOf(asn3));
194: }
195:
196: public void testDeletedAssignments() throws Exception {
197: // Make sure nothing awful happens when we ask for CourseGrade
198: // total points for an empty Gradebook
199: CourseGrade courseGrade = getCourseGradeWithStats(gradebook
200: .getId());
201: Assert.assertTrue(courseGrade.getMean() == null);
202:
203: List studentUidsList = Arrays.asList(new String[] {
204: "testStudentUserUid1", "testStudentUserUid2",
205: "testStudentUserUid3", });
206: addUsersEnrollments(gradebook, studentUidsList);
207: Set studentUids = new HashSet(studentUidsList);
208:
209: Long id1 = gradebookManager.createAssignment(gradebook.getId(),
210: ASN1_NAME, new Double(10), null, Boolean.FALSE,
211: Boolean.FALSE);
212: Long id2 = gradebookManager.createAssignment(gradebook.getId(),
213: ASN2_NAME, new Double(20), new Date(10), Boolean.FALSE,
214: Boolean.FALSE);
215: Long id3 = gradebookManager.createAssignment(gradebook.getId(),
216: ASN3_NAME, new Double(30), new Date(), Boolean.FALSE,
217: Boolean.FALSE);
218:
219: List assignments = gradebookManager.getAssignments(gradebook
220: .getId());
221: Assignment asn = gradebookManager.getAssignmentWithStats(id1);
222:
223: // Add some scores to the interesting assignment, leaving one student unscored.
224: List gradeRecords = new ArrayList();
225: gradeRecords.add(new AssignmentGradeRecord(asn,
226: (String) studentUidsList.get(0), new Double(8)));
227: gradeRecords.add(new AssignmentGradeRecord(asn,
228: (String) studentUidsList.get(1), new Double(9)));
229: gradebookManager
230: .updateAssignmentGradeRecords(asn, gradeRecords);
231:
232: // Remove the assignments.
233: // (We remove all of them to make sure that the calculated course grade can be emptied.)
234: gradebookManager.removeAssignment(id2);
235: gradebookManager.removeAssignment(id3);
236: gradebookManager.removeAssignment(id1);
237:
238: // Get the list of assignments again, and make sure it's missing the removed assignment
239: assignments = gradebookManager
240: .getAssignments(gradebook.getId());
241: Assert.assertTrue(!assignments.contains(asn));
242:
243: // And again, this time calculating statistics
244: assignments = gradebookManager.getAssignmentsWithStats(
245: gradebook.getId(), Assignment.SORT_BY_NAME, true);
246: Assert.assertTrue(!assignments.contains(asn));
247:
248: // Get the grade records for this gradebook, and make sure none of them
249: // belong to a removed assignment
250: gradeRecords = gradebookManager.getAllAssignmentGradeRecords(
251: gradebook.getId(), studentUids);
252: assertNoneFromRemovedAssignments(gradeRecords);
253:
254: // Get the grade records for this assignment. None should be returned, since
255: // it has been removed.
256: gradeRecords = gradebookManager.getAssignmentGradeRecords(asn,
257: studentUids);
258: assertNoneFromRemovedAssignments(gradeRecords);
259: Assert.assertTrue(gradeRecords.size() == 0);
260:
261: // Make sure we can add a new assignment with the same name as the removed one.
262: // This will throw an exception if it doesn't like the assignment name.
263: gradebookManager.createAssignment(gradebook.getId(), ASN1_NAME,
264: new Double(10), new Date(), Boolean.FALSE,
265: Boolean.FALSE);
266: }
267:
268: /**
269: * Ensures that none of the grade records passed in belong to a removed assignment.
270: *
271: * @param gradeRecords
272: */
273: private void assertNoneFromRemovedAssignments(
274: Collection gradeRecords) {
275: for (Iterator iter = gradeRecords.iterator(); iter.hasNext();) {
276: AbstractGradeRecord gr = (AbstractGradeRecord) iter.next();
277: Assert.assertTrue(!gr.getGradableObject().isRemoved());
278: }
279: }
280:
281: /**
282: * Create, remove, and re-add some assignments to ensure that the total
283: * points calculation remains accurate.
284: *
285: * @throws Exception
286: */
287: public void testTotalPointsInGradebook() throws Exception {
288: Long id1 = gradebookManager.createAssignment(gradebook.getId(),
289: ASN1_NAME, new Double(10), null, Boolean.FALSE,
290: Boolean.FALSE);
291: gradebookManager.createAssignment(gradebook.getId(), ASN2_NAME,
292: new Double(20), new Date(10), Boolean.FALSE,
293: Boolean.FALSE);
294: gradebookManager.createAssignment(gradebook.getId(), ASN3_NAME,
295: new Double(30), new Date(), Boolean.FALSE,
296: Boolean.FALSE);
297:
298: double totalPointsPossible = gradebookManager
299: .getTotalPoints(gradebook.getId());
300: Assert.assertTrue(totalPointsPossible == 60);
301:
302: gradebookManager.removeAssignment(id1);
303:
304: totalPointsPossible = gradebookManager.getTotalPoints(gradebook
305: .getId());
306: Assert.assertTrue(totalPointsPossible == 50);
307:
308: gradebookManager.createAssignment(gradebook.getId(), ASN1_NAME,
309: new Double(50), null, Boolean.FALSE, Boolean.FALSE);
310:
311: totalPointsPossible = gradebookManager.getTotalPoints(gradebook
312: .getId());
313: Assert.assertTrue(totalPointsPossible == 100);
314: }
315: }
|