001: /**********************************************************************************
002: *
003: * $Id: GradebookServiceInternalTest.java 28316 2007-04-04 18:18:49Z ajpoland@iupui.edu $
004: *
005: ***********************************************************************************
006: *
007: * Copyright (c) 2005, 2006 The Regents of the University of California, The MIT Corporation
008: *
009: * Licensed under the Educational Community License Version 1.0 (the "License");
010: * By obtaining, using and/or copying this Original Work, you agree that you have read,
011: * understand, and will comply with the terms and conditions of the Educational Community License.
012: * You may obtain a copy of the License at:
013: *
014: * http://www.opensource.org/licenses/ecl1.php
015: *
016: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
017: * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
018: * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
019: * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
020: * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
021: *
022: **********************************************************************************/package org.sakaiproject.tool.gradebook.test;
023:
024: import java.io.ByteArrayInputStream;
025: import java.io.ByteArrayOutputStream;
026: import java.io.ObjectInputStream;
027: import java.io.ObjectOutputStream;
028: import java.io.StringReader;
029: import java.io.UnsupportedEncodingException;
030: import java.util.ArrayList;
031: import java.util.Arrays;
032: import java.util.Date;
033: import java.util.HashMap;
034: import java.util.Iterator;
035: import java.util.List;
036: import java.util.Map;
037:
038: import javax.xml.parsers.DocumentBuilder;
039: import javax.xml.parsers.DocumentBuilderFactory;
040: import javax.xml.transform.Transformer;
041: import javax.xml.transform.TransformerException;
042: import javax.xml.transform.TransformerFactory;
043: import javax.xml.transform.dom.DOMSource;
044: import javax.xml.transform.stream.StreamResult;
045:
046: import junit.framework.Assert;
047:
048: import org.apache.commons.logging.Log;
049: import org.apache.commons.logging.LogFactory;
050: import org.sakaiproject.component.gradebook.GradebookDefinition;
051: import org.sakaiproject.component.gradebook.VersionedExternalizable;
052: import org.sakaiproject.section.api.coursemanagement.Course;
053: import org.sakaiproject.section.api.coursemanagement.CourseSection;
054: import org.sakaiproject.section.api.facade.Role;
055: import org.sakaiproject.service.gradebook.shared.AssessmentNotFoundException;
056: import org.sakaiproject.service.gradebook.shared.Assignment;
057: import org.sakaiproject.service.gradebook.shared.AssignmentHasIllegalPointsException;
058: import org.sakaiproject.service.gradebook.shared.CommentDefinition;
059: import org.sakaiproject.service.gradebook.shared.ConflictingAssignmentNameException;
060: import org.sakaiproject.service.gradebook.shared.GradingScaleDefinition;
061: import org.sakaiproject.tool.gradebook.AssignmentGradeRecord;
062: import org.sakaiproject.tool.gradebook.Comment;
063: import org.sakaiproject.tool.gradebook.GradeMapping;
064: import org.sakaiproject.tool.gradebook.Gradebook;
065: import org.sakaiproject.tool.gradebook.GradingEvents;
066: import org.w3c.dom.Document;
067: import org.w3c.dom.Element;
068: import org.xml.sax.InputSource;
069:
070: import com.thoughtworks.xstream.converters.ConversionException;
071:
072: /**
073: * Test the service methods which interact with internally maintained data.
074: * These methods have more complex authorization requirements.
075: */
076: public class GradebookServiceInternalTest extends GradebookTestBase {
077:
078: private static final Log log = LogFactory
079: .getLog(GradebookServiceInternalTest.class);
080:
081: private static final String GRADEBOOK_UID = "gradebookServiceTest";
082: private static final String ASN_TITLE = "Assignment #1";
083: private static final String EXT_ID_1 = "External #1";
084: private static final String EXT_TITLE_1 = "External Title #1";
085: private static final String INSTRUCTOR_UID = "Inst-1";
086: private static final String TA_UID = "TA-1";
087: private static final String SECTION_NAME = "Lab 01";
088: private static final String STUDENT_IN_SECTION_UID = "StudentInLab";
089: private static final String STUDENT_NOT_IN_SECTION_UID = "StudentNotInLab";
090: private static final Double ASN_POINTS = new Double(40.0);
091: private Long asnId;
092:
093: /**
094: * @see org.springframework.test.AbstractTransactionalSpringContextTests#onSetUpInTransaction()
095: */
096: protected void onSetUpInTransaction() throws Exception {
097: super .onSetUpInTransaction();
098: gradebookFrameworkService.addGradebook(GRADEBOOK_UID,
099: GRADEBOOK_UID);
100: Gradebook gradebook = gradebookManager
101: .getGradebook(GRADEBOOK_UID);
102:
103: // Set up users, enrollments, teaching assignments, and sections.
104: Course courseSite = integrationSupport.createCourse(
105: GRADEBOOK_UID, GRADEBOOK_UID, false, false, false);
106: addUsersEnrollments(gradebook, Arrays.asList(new String[] {
107: STUDENT_IN_SECTION_UID, STUDENT_NOT_IN_SECTION_UID }));
108: userManager.createUser(INSTRUCTOR_UID, null, null, null);
109: integrationSupport.addSiteMembership(INSTRUCTOR_UID,
110: GRADEBOOK_UID, Role.INSTRUCTOR);
111: userManager.createUser(TA_UID, null, null, null);
112: integrationSupport.addSiteMembership(TA_UID, GRADEBOOK_UID,
113: Role.TA);
114: List sectionCategories = sectionAwareness
115: .getSectionCategories(GRADEBOOK_UID);
116: CourseSection section = integrationSupport.createSection(
117: courseSite.getUuid(), SECTION_NAME,
118: (String) sectionCategories.get(0), new Integer(40),
119: null, null, null, true, false, true, false, false,
120: false, false);
121: integrationSupport.addSectionMembership(STUDENT_IN_SECTION_UID,
122: section.getUuid(), Role.STUDENT);
123: integrationSupport.addSectionMembership(TA_UID, section
124: .getUuid(), Role.TA);
125:
126: // Add an internal assignment.
127: asnId = gradebookManager.createAssignment(gradebook.getId(),
128: ASN_TITLE, ASN_POINTS, new Date(), Boolean.FALSE,
129: Boolean.FALSE);
130:
131: // Add an external assessment.
132: gradebookExternalAssessmentService.addExternalAssessment(
133: GRADEBOOK_UID, EXT_ID_1, null, EXT_TITLE_1, 10, null,
134: "Samigo");
135: }
136:
137: public void testGradebookMigration() throws Exception {
138: setAuthnId(INSTRUCTOR_UID);
139: Gradebook gradebook = gradebookManager
140: .getGradebook(GRADEBOOK_UID);
141:
142: // Collect the default grade mappings for future reference.
143: GradeMapping defaultGradeMapping = gradebook
144: .getSelectedGradeMapping();
145: GradeMapping nonDefaultGradeMapping = null;
146: for (GradeMapping gradeMapping : gradebook.getGradeMappings()) {
147: if (!gradeMapping.getName().equals(
148: defaultGradeMapping.getName())) {
149: nonDefaultGradeMapping = gradeMapping;
150: break;
151: }
152: }
153: String firstGrade = nonDefaultGradeMapping.getGradingScale()
154: .getGrades().get(0);
155: double originalFirstGradeValue = nonDefaultGradeMapping
156: .getGradeMap().get(firstGrade).doubleValue();
157: if (log.isDebugEnabled())
158: log.debug("nonDefaultGradeMapping="
159: + nonDefaultGradeMapping.getGradingScale().getUid()
160: + ", firstGrade=" + firstGrade + ", value="
161: + originalFirstGradeValue);
162:
163: gradebookManager.createAssignment(gradebook.getId(),
164: "Duplicate", new Double(100), null, Boolean.TRUE,
165: Boolean.TRUE);
166: gradebookManager.createAssignment(gradebook.getId(),
167: "Released", new Double(50), null, Boolean.FALSE,
168: Boolean.TRUE);
169: nonDefaultGradeMapping.getGradeMap().put(firstGrade,
170: new Double(originalFirstGradeValue - 1.0));
171: gradebook.setSelectedGradeMapping(nonDefaultGradeMapping);
172: gradebook.setAssignmentsDisplayed(false); // Override the defaults
173: gradebook.setCourseGradeDisplayed(true);
174: gradebookManager.updateGradebook(gradebook);
175:
176: String gradebookXml = gradebookService
177: .getGradebookDefinitionXml(GRADEBOOK_UID);
178: GradebookDefinition gradebookDefinition = (GradebookDefinition) VersionedExternalizable
179: .fromXml(gradebookXml);
180: if (log.isDebugEnabled())
181: log.debug("gradebookXml=" + gradebookXml);
182:
183: // Create the target gradebook.
184: String migrateToUid = "MigrateTo";
185: Gradebook newGradebook = getNewGradebook(migrateToUid);
186: gradebookManager.createAssignment(newGradebook.getId(),
187: "Duplicate", new Double(1.0), new Date(),
188: Boolean.FALSE, Boolean.FALSE);
189:
190: // Try to merge the old definition in.
191: gradebookService.mergeGradebookDefinitionXml(migrateToUid,
192: gradebookXml);
193: newGradebook = gradebookManager.getGradebook(migrateToUid);
194:
195: // Make sure the old assignments were merged in.
196: List assignments = gradebookService
197: .getAssignments(migrateToUid);
198: Map<String, Assignment> assignmentMap = new HashMap<String, Assignment>();
199: for (Object obj : assignments) {
200: Assignment assignment = (Assignment) obj;
201: assignmentMap.put(assignment.getName(), assignment);
202: }
203: Assert.assertTrue(assignmentMap.containsKey(ASN_TITLE));
204:
205: // All assignments should be unreleased even if they were released in the original.
206: Assignment released = assignmentMap.get("Released");
207: Assert.assertTrue(!released.isReleased());
208: Assert.assertTrue(released.isCounted());
209:
210: // Externally managed assessments should not be included.
211: Assert.assertTrue(!assignmentMap.containsKey(EXT_TITLE_1));
212:
213: // Assignments with duplicate names shouldn't override existing assignments.
214: Assignment duplicate = assignmentMap.get("Duplicate");
215: Assert.assertTrue(duplicate.getPoints().doubleValue() == 1.0);
216:
217: // Student view options should stay as they were.
218: Assert.assertTrue(newGradebook.isAssignmentsDisplayed());
219: Assert.assertTrue(!newGradebook.isCourseGradeDisplayed());
220:
221: // Carry over the old gradebook's selected grading scheme if possible.
222: GradeMapping migratedGradeMapping = newGradebook
223: .getSelectedGradeMapping();
224: Assert.assertTrue(migratedGradeMapping.getName().equals(
225: nonDefaultGradeMapping.getName()));
226: Assert.assertTrue(migratedGradeMapping.getGradeMap().get(
227: firstGrade).doubleValue() != originalFirstGradeValue);
228:
229: // If the old grading scheme is not available to the new gradebook, leave
230: // the new gradebook's grading scheme alone.
231: List newMappings = new ArrayList();
232: GradingScaleDefinition def = new GradingScaleDefinition();
233: def.setUid("BettingScale");
234: def.setName("Just One Grading Scale");
235: def.setGrades(Arrays.asList(new String[] { "Win", "Draw",
236: "Lose" }));
237: def.setDefaultBottomPercents(Arrays.asList(new Object[] {
238: new Double(80), new Double(40), new Double(0) }));
239: newMappings.add(def);
240: gradebookFrameworkService
241: .setAvailableGradingScales(newMappings);
242: getNewGradebook("BettingGradebook");
243: gradebookXml = gradebookService
244: .getGradebookDefinitionXml("BettingGradebook");
245: gradebookService.mergeGradebookDefinitionXml(migrateToUid,
246: gradebookXml);
247: newGradebook = gradebookManager.getGradebook(migrateToUid);
248: Assert.assertTrue(newGradebook.getSelectedGradeMapping()
249: .getName().equals(nonDefaultGradeMapping.getName()));
250:
251: // Test the Externalizable feature.
252: ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
253: ObjectOutputStream objOut = new ObjectOutputStream(byteOut);
254: gradebookDefinition.writeExternal(objOut);
255: objOut.close(); // Required to close the XML string
256: if (log.isDebugEnabled())
257: log.debug("externalized gradebook="
258: + byteOut.toString("UTF-8"));
259: GradebookDefinition restoredGradebookDefinition = new GradebookDefinition();
260: restoredGradebookDefinition.readExternal(new ObjectInputStream(
261: new ByteArrayInputStream(byteOut.toByteArray())));
262: if (log.isDebugEnabled())
263: log.debug("restored gradebook="
264: + restoredGradebookDefinition);
265: }
266:
267: private Gradebook getNewGradebook(String gradebookUid) {
268: integrationSupport.createCourse(gradebookUid, gradebookUid,
269: false, false, false);
270: gradebookFrameworkService.addGradebook(gradebookUid,
271: gradebookUid);
272: integrationSupport.addSiteMembership(INSTRUCTOR_UID,
273: gradebookUid, Role.INSTRUCTOR);
274: return gradebookManager.getGradebook(gradebookUid);
275: }
276:
277: public void testGradebookMigrationVersioning() throws Exception {
278: setAuthnId(INSTRUCTOR_UID);
279: String gradebookXml = gradebookService
280: .getGradebookDefinitionXml(GRADEBOOK_UID);
281:
282: DocumentBuilder documentBuilder = DocumentBuilderFactory
283: .newInstance().newDocumentBuilder();
284: Document document = documentBuilder.parse(new InputSource(
285: new StringReader(gradebookXml)));
286: Element gradebookElement = document.getDocumentElement();
287: String versionXml = gradebookElement
288: .getAttribute(VersionedExternalizable.VERSION_ATTRIBUTE);
289: Assert.assertTrue(versionXml
290: .equals(GradebookDefinition.EXTERNALIZABLE_VERSION));
291:
292: // Mess with the converter's mind and make sure it's displeased.
293: gradebookElement
294: .removeAttribute(VersionedExternalizable.VERSION_ATTRIBUTE);
295: gradebookElement.setAttribute(
296: VersionedExternalizable.VERSION_ATTRIBUTE,
297: "Who are you kidding?");
298: try {
299: String newXml = documentToString(document);
300: VersionedExternalizable.fromXml(newXml);
301: fail();
302: } catch (ConversionException e) {
303: }
304: }
305:
306: public static String documentToString(Document doc) {
307: String result = null;
308: try {
309: // Work around JDK 1.5 issue.
310: System
311: .setProperty(
312: "javax.xml.transform.TransformerFactory",
313: "com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl");
314: Transformer transformer = TransformerFactory.newInstance()
315: .newTransformer();
316: ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
317: transformer.transform(new DOMSource(doc
318: .getDocumentElement()), new StreamResult(byteOut));
319: if (byteOut != null) {
320: result = byteOut.toString("UTF-8");
321: }
322: } catch (TransformerException e) {
323: log.error(e);
324: } catch (UnsupportedEncodingException e) {
325: log.error(e);
326: }
327: return result;
328: }
329:
330: public void testStudentRebuff() throws Exception {
331: setAuthnId(INSTRUCTOR_UID);
332:
333: // Score the unreleased assignment.
334: gradebookService.setAssignmentScore(GRADEBOOK_UID, ASN_TITLE,
335: STUDENT_IN_SECTION_UID, new Double(39), "Service Test");
336:
337: // Try to get a list of assignments as the student.
338: setAuthnId(STUDENT_IN_SECTION_UID);
339: try {
340: if (log.isInfoEnabled())
341: log.info("Ignore the upcoming authorization errors...");
342: gradebookService.getAssignments(GRADEBOOK_UID);
343: fail();
344: } catch (SecurityException e) {
345: }
346:
347: // And then try to get the score.
348: Double score;
349: try {
350: score = gradebookService.getAssignmentScore(GRADEBOOK_UID,
351: ASN_TITLE, STUDENT_IN_SECTION_UID);
352: fail();
353: } catch (SecurityException e) {
354: }
355:
356: // Now release the assignment.
357: setAuthnId(INSTRUCTOR_UID);
358: org.sakaiproject.tool.gradebook.Assignment assignment = gradebookManager
359: .getAssignment(asnId);
360: assignment.setReleased(true);
361: gradebookManager.updateAssignment(assignment);
362:
363: // Now see if the student gets lucky.
364: setAuthnId(STUDENT_IN_SECTION_UID);
365: score = gradebookService.getAssignmentScore(GRADEBOOK_UID,
366: ASN_TITLE, STUDENT_IN_SECTION_UID);
367: Assert.assertTrue(score.doubleValue() == 39.0);
368: }
369:
370: public void testExternalClientSupport() throws Exception {
371: setAuthnId(TA_UID);
372:
373: List assignments = gradebookService
374: .getAssignments(GRADEBOOK_UID);
375: Assert.assertTrue(assignments.size() == 2);
376:
377: for (Iterator iter = assignments.iterator(); iter.hasNext();) {
378: Assignment assignment = (Assignment) iter.next();
379:
380: if (assignment.isExternallyMaintained()) {
381: Assert.assertTrue(EXT_TITLE_1.equals(assignment
382: .getName()));
383: // Make sure we can't update it.
384: boolean gotSecurityException = false;
385: try {
386: if (log.isInfoEnabled())
387: log
388: .info("Ignore the upcoming authorization error...");
389: gradebookService.setAssignmentScore(GRADEBOOK_UID,
390: EXT_TITLE_1, STUDENT_IN_SECTION_UID,
391: new Double(9), "Service Test");
392: } catch (SecurityException e) {
393: gotSecurityException = true;
394: }
395: Assert.assertTrue(gotSecurityException);
396: } else {
397: Assert.assertTrue(ASN_TITLE
398: .equals(assignment.getName()));
399: Assert.assertTrue(assignment.getPoints().equals(
400: ASN_POINTS));
401:
402: Assert.assertFalse(gradebookService
403: .isUserAbleToGradeStudent(GRADEBOOK_UID,
404: STUDENT_NOT_IN_SECTION_UID));
405: boolean gotSecurityException = false;
406: try {
407: if (log.isInfoEnabled())
408: log
409: .info("Ignore the upcoming authorization error...");
410: gradebookService.getAssignmentScore(GRADEBOOK_UID,
411: ASN_TITLE, STUDENT_NOT_IN_SECTION_UID);
412: } catch (SecurityException e) {
413: gotSecurityException = true;
414: }
415: gotSecurityException = false;
416: try {
417: if (log.isInfoEnabled())
418: log
419: .info("Ignore the upcoming authorization error...");
420: gradebookService.setAssignmentScore(GRADEBOOK_UID,
421: ASN_TITLE, STUDENT_NOT_IN_SECTION_UID,
422: new Double(39), "Service Test");
423: } catch (SecurityException e) {
424: gotSecurityException = true;
425: }
426: Assert.assertTrue(gotSecurityException);
427:
428: Assert.assertTrue(gradebookService
429: .isUserAbleToGradeStudent(GRADEBOOK_UID,
430: STUDENT_IN_SECTION_UID));
431: Double score = gradebookService.getAssignmentScore(
432: GRADEBOOK_UID, ASN_TITLE,
433: STUDENT_IN_SECTION_UID);
434: Assert.assertTrue(score == null);
435: gradebookService.setAssignmentScore(GRADEBOOK_UID,
436: ASN_TITLE, STUDENT_IN_SECTION_UID, new Double(
437: 39), "Service Test");
438: score = gradebookService.getAssignmentScore(
439: GRADEBOOK_UID, ASN_TITLE,
440: STUDENT_IN_SECTION_UID);
441: Assert.assertTrue(score.doubleValue() == 39.0);
442:
443: // Make sure a record was made in the history log.
444: List studentUids = Arrays
445: .asList(new String[] { STUDENT_IN_SECTION_UID, });
446: GradingEvents gradingEvents = gradebookManager
447: .getGradingEvents(gradebookManager
448: .getAssignment(asnId), studentUids);
449: List events = gradingEvents
450: .getEvents(STUDENT_IN_SECTION_UID);
451: Assert.assertTrue(events.size() == 1);
452:
453: // Also test the case where there's a score already there.
454: gradebookService.setAssignmentScore(GRADEBOOK_UID,
455: ASN_TITLE, STUDENT_IN_SECTION_UID, new Double(
456: 37), "Different Service Test");
457: score = gradebookService.getAssignmentScore(
458: GRADEBOOK_UID, ASN_TITLE,
459: STUDENT_IN_SECTION_UID);
460: Assert.assertTrue(score.doubleValue() == 37.0);
461: }
462: }
463: }
464:
465: public void testAddAssignment() throws Exception {
466: setAuthnId(INSTRUCTOR_UID);
467:
468: // Create an assignment definition.
469: String assignmentName = "Client-Created Quiz";
470: Assignment assignmentDefinition = new Assignment();
471: assignmentDefinition.setName(assignmentName);
472: assignmentDefinition.setPoints(new Double(50));
473: gradebookService.addAssignment(GRADEBOOK_UID,
474: assignmentDefinition);
475:
476: // Make sure it's there and we can grade it.
477: gradebookService.setAssignmentScore(GRADEBOOK_UID,
478: assignmentName, STUDENT_IN_SECTION_UID, new Double(49),
479: "Service Test");
480: Double score = gradebookService.getAssignmentScore(
481: GRADEBOOK_UID, assignmentName, STUDENT_IN_SECTION_UID);
482: Assert.assertTrue(score.doubleValue() == 49.0);
483:
484: // Make sure we can't add duplicate names.
485: assignmentDefinition.setPoints(new Double(40));
486: try {
487: gradebookService.addAssignment(GRADEBOOK_UID,
488: assignmentDefinition);
489: fail();
490: } catch (ConflictingAssignmentNameException e) {
491: }
492:
493: // Make sure we don't accept zero-score assignments (at present).
494: assignmentDefinition.setName("Illegal Assignment");
495: assignmentDefinition.setPoints(new Double(0));
496: try {
497: gradebookService.addAssignment(GRADEBOOK_UID,
498: assignmentDefinition);
499: fail();
500: } catch (AssignmentHasIllegalPointsException e) {
501: }
502:
503: // Make sure we don't panic about unreal assignments.
504: assignmentDefinition = gradebookService.getAssignment(
505: GRADEBOOK_UID, "No Such Assignment");
506: Assert.assertTrue(assignmentDefinition == null);
507: }
508:
509: public void testMoveExternalToInternal() throws Exception {
510: // Add an external assessment score.
511: gradebookExternalAssessmentService
512: .updateExternalAssessmentScore(GRADEBOOK_UID, EXT_ID_1,
513: STUDENT_IN_SECTION_UID, new Double(5));
514:
515: // Break the relationship off.
516: gradebookExternalAssessmentService
517: .setExternalAssessmentToGradebookAssignment(
518: GRADEBOOK_UID, EXT_ID_1);
519:
520: // Make sure that the internal-access APIs work now.
521: setAuthnId(INSTRUCTOR_UID);
522: Double score = gradebookService.getAssignmentScore(
523: GRADEBOOK_UID, EXT_TITLE_1, STUDENT_IN_SECTION_UID);
524: Assert.assertTrue(score.doubleValue() == 5.0);
525: gradebookService.setAssignmentScore(GRADEBOOK_UID, EXT_TITLE_1,
526: STUDENT_IN_SECTION_UID, new Double(10), "A Friend");
527: score = gradebookService.getAssignmentScore(GRADEBOOK_UID,
528: EXT_TITLE_1, STUDENT_IN_SECTION_UID);
529: Assert.assertTrue(score.doubleValue() == 10.0);
530:
531: // Make sure that the external-management fields are nulled out.
532: org.sakaiproject.service.gradebook.shared.Assignment assignmentDefinition = gradebookService
533: .getAssignment(GRADEBOOK_UID, EXT_TITLE_1);
534: Assert.assertTrue(!assignmentDefinition
535: .isExternallyMaintained());
536: Assert
537: .assertTrue(assignmentDefinition.getExternalAppName() == null);
538:
539: // Make sure that the external-management APIs don't work any more.
540: try {
541: gradebookExternalAssessmentService
542: .updateExternalAssessmentScore(GRADEBOOK_UID,
543: EXT_ID_1, STUDENT_IN_SECTION_UID,
544: new Double(5));
545: fail();
546: } catch (AssessmentNotFoundException e) {
547: }
548: }
549:
550: public void testUpdateAssignment() throws Exception {
551: setAuthnId(INSTRUCTOR_UID);
552: org.sakaiproject.service.gradebook.shared.Assignment assignmentDefinition = gradebookService
553: .getAssignment(GRADEBOOK_UID, ASN_TITLE);
554:
555: // Make sure we can change the points even if a student's been scored.
556: double oldPoints = assignmentDefinition.getPoints();
557: gradebookService.setAssignmentScore(GRADEBOOK_UID, ASN_TITLE,
558: STUDENT_IN_SECTION_UID, new Double(39), "Service Test");
559: assignmentDefinition.setPoints(oldPoints * 2);
560: gradebookService.updateAssignment(GRADEBOOK_UID, ASN_TITLE,
561: assignmentDefinition);
562: assignmentDefinition = gradebookService.getAssignment(
563: GRADEBOOK_UID, ASN_TITLE);
564: Assert.assertTrue(assignmentDefinition.getPoints()
565: .doubleValue() != oldPoints);
566:
567: // Make sure we can change the assignment title.
568: String newAsnTitle = "Changed Quiz";
569: assignmentDefinition.setName(newAsnTitle);
570: gradebookService.updateAssignment(GRADEBOOK_UID, ASN_TITLE,
571: assignmentDefinition);
572: assignmentDefinition = gradebookService.getAssignment(
573: GRADEBOOK_UID, ASN_TITLE);
574: Assert.assertTrue(assignmentDefinition == null);
575: assignmentDefinition = gradebookService.getAssignment(
576: GRADEBOOK_UID, newAsnTitle);
577: Assert.assertTrue(assignmentDefinition != null);
578:
579: // Check for duplicate assignment titles.
580: assignmentDefinition.setName(EXT_TITLE_1);
581: try {
582: gradebookService.updateAssignment(GRADEBOOK_UID,
583: newAsnTitle, assignmentDefinition);
584: fail();
585: } catch (ConflictingAssignmentNameException e) {
586: }
587:
588: // Don't allow changes to externally-managed assessments.
589: assignmentDefinition = gradebookService.getAssignment(
590: GRADEBOOK_UID, EXT_TITLE_1);
591: assignmentDefinition.setExternallyMaintained(false);
592: assignmentDefinition.setPoints(10.0);
593: try {
594: gradebookService.updateAssignment(GRADEBOOK_UID,
595: EXT_TITLE_1, assignmentDefinition);
596: fail();
597: } catch (SecurityException e) {
598: }
599:
600: // Don't change a Gradebook-managed assignment into an externally-managed assessment.
601: assignmentDefinition = gradebookService.getAssignment(
602: GRADEBOOK_UID, newAsnTitle);
603: assignmentDefinition.setExternallyMaintained(true);
604: assignmentDefinition.setExternalAppName("Mr. Sparkle");
605: try {
606: gradebookService.updateAssignment(GRADEBOOK_UID,
607: newAsnTitle, assignmentDefinition);
608: fail();
609: } catch (SecurityException e) {
610: }
611:
612: // Don't let students change assignment defintions.
613: assignmentDefinition = gradebookService.getAssignment(
614: GRADEBOOK_UID, newAsnTitle);
615: setAuthnId(STUDENT_IN_SECTION_UID);
616: assignmentDefinition.setPoints(10.0);
617: try {
618: gradebookService.updateAssignment(GRADEBOOK_UID,
619: newAsnTitle, assignmentDefinition);
620: fail();
621: } catch (SecurityException e) {
622: }
623: }
624:
625: public void testAssignmentScoreComment() throws Exception {
626: setAuthnId(INSTRUCTOR_UID);
627:
628: // Comment on a student score as if the Gradebook application was doing it.
629: org.sakaiproject.tool.gradebook.Assignment assignment = gradebookManager
630: .getAssignment(asnId);
631: List<AssignmentGradeRecord> gradeRecords = new ArrayList<AssignmentGradeRecord>();
632: List<Comment> comments = Arrays
633: .asList(new Comment[] { new Comment(
634: STUDENT_IN_SECTION_UID, "First comment",
635: assignment) });
636: gradebookManager.updateAssignmentGradesAndComments(assignment,
637: gradeRecords, comments);
638:
639: // Make sure we don't get a comment for the student who doesn't have one.
640: CommentDefinition commentDefinition = gradebookService
641: .getAssignmentScoreComment(GRADEBOOK_UID, ASN_TITLE,
642: STUDENT_NOT_IN_SECTION_UID);
643: Assert.assertTrue(commentDefinition == null);
644:
645: // Make sure we can retrieve the comment.
646: commentDefinition = gradebookService.getAssignmentScoreComment(
647: GRADEBOOK_UID, ASN_TITLE, STUDENT_IN_SECTION_UID);
648: Assert.assertTrue(commentDefinition.getAssignmentName().equals(
649: ASN_TITLE));
650: Assert.assertTrue(commentDefinition.getCommentText().equals(
651: "First comment"));
652: Assert.assertTrue(commentDefinition.getGraderUid().equals(
653: INSTRUCTOR_UID));
654: Assert.assertTrue(commentDefinition.getStudentUid().equals(
655: STUDENT_IN_SECTION_UID));
656:
657: // Now change the comment.
658: setAuthnId(TA_UID);
659: gradebookService.setAssignmentScoreComment(GRADEBOOK_UID,
660: ASN_TITLE, STUDENT_IN_SECTION_UID, "Second comment");
661: commentDefinition = gradebookService.getAssignmentScoreComment(
662: GRADEBOOK_UID, ASN_TITLE, STUDENT_IN_SECTION_UID);
663: Assert.assertTrue(commentDefinition.getCommentText().equals(
664: "Second comment"));
665: Assert.assertTrue(commentDefinition.getGraderUid().equals(
666: TA_UID));
667: }
668:
669: }
|