Merge pull request #79 from edx/will/self-assessment-api

Self-assessment (Tim-240)

apps/openassessment/peer/admin.py → apps/openassessment/assessment/admin.py

 from django.contrib import admin
 
-from openassessment.peer.models import Assessment, AssessmentPart, Rubric, Criterion, CriterionOption
+from openassessment.assessment.models import Assessment, AssessmentPart, Rubric, Criterion, CriterionOption
 
 admin.site.register(Assessment)
 admin.site.register(AssessmentPart)

apps/openassessment/peer/models.py → apps/openassessment/assessment/models.py

@@ -11,11 +11,19 @@ import json
 
 from django.db import models
 from django.utils.timezone import now
+from django.utils.translation import ugettext as _
 import math
 
 from submissions.models import Submission
 
 
+class InvalidOptionSelection(Exception):
+    """
+    The user selected options that do not match the rubric.
+    """
+    pass
+
+
 class Rubric(models.Model):
     """A Rubric contains the guidelines on how to assess a submission.
 
@@ -82,28 +90,50 @@ class Rubric(models.Model):
                 the option that was selected for that criterion.
 
         Returns:
-            list of option ids (set to None if the selected option does not match the rubric)
+            set of option ids
 
         Examples:
             >>> options_selected = {"secret": "yes", "safe": "no"}
             >>> rubric.options_ids(options_selected)
             [10, 12]
 
+        Raises:
+            InvalidOptionSelection: the selected options do not match the rubric.
+
         """
-        # TODO: cache this
-        crit_to_all_opts = {
-            crit.name : {
-                option.name: option.id for option in crit.options.all()
-            }
-            for crit in self.criteria.all()
-        }
+        # Select all criteria and options for this rubric
+        # We use `select_related()` to minimize the number of database queries
+        rubric_options = CriterionOption.objects.filter(criterion__rubric=self).select_related()
+
+        # Create a dict of dicts that maps:
+        # criterion names --> option names --> option ids
+        rubric_criteria_dict = defaultdict(dict)
+
+        # Construct dictionaries for each option in the rubric
+        for option in rubric_options:
+            rubric_criteria_dict[option.criterion.name][option.name] = option.id
+
+        # Validate: are options selected for each criterion in the rubric?
+        if len(options_selected) != len(rubric_criteria_dict):
+            msg = _("Incorrect number of options for this rubric ({actual} instead of {expected}").format(
+                actual=len(options_selected), expected=len(rubric_criteria_dict))
+            raise InvalidOptionSelection(msg)
+
+        # Look up each selected option
+        option_id_set = set()
+        for criterion_name, option_name in options_selected.iteritems():
+            if (criterion_name in rubric_criteria_dict and
+                option_name in rubric_criteria_dict[criterion_name]
+            ):
+                option_id = rubric_criteria_dict[criterion_name][option_name]
+                option_id_set.add(option_id)
+            else:
+                msg = _("{criterion}: {option} not found in rubric").format(
+                    criterion=criterion_name, option=option_name
+                )
+                raise InvalidOptionSelection(msg)
 
-        return [
-            crit_to_all_opts[crit][opt]
-            if crit in crit_to_all_opts and opt in crit_to_all_opts[crit]
-            else None
-            for crit, opt in options_selected.items()
-        ]
+        return option_id_set
 
 
 class Criterion(models.Model):
@@ -191,7 +221,7 @@ class Assessment(models.Model):
     scorer_id = models.CharField(max_length=40, db_index=True)
     score_type = models.CharField(max_length=2)
 
-    feedback = models.TextField(max_length=10000, default="")
+    feedback = models.TextField(max_length=10000, default="", blank=True)
 
     class Meta:
         ordering = ["-scored_at"]

apps/openassessment/peer/api.py → apps/openassessment/assessment/peer_api.py

@@ -10,8 +10,8 @@ import logging
 from django.utils.translation import ugettext as _
 from django.db import DatabaseError
 
-from openassessment.peer.models import Assessment
-from openassessment.peer.serializers import (
+from openassessment.assessment.models import Assessment, InvalidOptionSelection
+from openassessment.assessment.serializers import (
     AssessmentSerializer, rubric_from_dict, get_assessment_review)
 from submissions import api as submission_api
 from submissions.models import Submission, StudentItem, Score
@@ -73,6 +73,7 @@ def is_complete(submission_uuid, requirements):
     )
     return finished_evaluating
 
+
 def get_score(submission_uuid, requirements):
     # User hasn't completed their own submission yet
     if not is_complete(submission_uuid, requirements):
@@ -117,9 +118,10 @@ def create_assessment(
             required for the student to receive a score for their submission.
         must_be_graded_by (int): The number of assessments
             required on the submission for it to be scored.
-        assessment_dict (dict): All related information for the assessment.  The dictionary
-            must have the following keys: "options_selected" (mapping of criterion names to option values),
-            and "feedback" (string of written feedback for the submission).
+        assessment_dict (dict): All related information for the assessment. An
+            assessment contains points_earned, points_possible, and feedback.
+
+    Kwargs:
         scored_at (datetime): Optional argument to override the time in which
             the assessment took place. If not specified, scored_at is set to
             now.
@@ -145,12 +147,14 @@ def create_assessment(
         submission = Submission.objects.get(uuid=submission_uuid)
         student_item = submission.student_item
         rubric = rubric_from_dict(rubric_dict)
-        option_ids = rubric.options_ids(assessment_dict["options_selected"])
 
         # Validate that the selected options matched the rubric
         # and raise an error if this is not the case
-        if None in option_ids:
-            raise PeerAssessmentRequestError(_("Selected options do not match the rubric options."))
+        try:
+            option_ids = rubric.options_ids(assessment_dict["options_selected"])
+        except InvalidOptionSelection as ex:
+            msg = _("Selected options do not match the rubric: {error}").format(error=ex.message)
+            raise PeerAssessmentRequestError(msg)
 
         # Check if the grader has even submitted an answer themselves...
         try:
@@ -195,6 +199,36 @@ def create_assessment(
         raise PeerAssessmentInternalError(error_message)
 
 
+def _score_if_finished(student_item,
+                       submission,
+                       required_assessments_for_student,
+                       must_be_graded_by):
+    """Calculate final grade iff peer evaluation flow is satisfied.
+
+    Checks if the student is finished with the peer assessment workflow. If the
+    student already has a final grade calculated, there is no need to proceed.
+    If they do not have a grade, the student has a final grade calculated.
+
+    """
+    if Score.objects.filter(student_item=student_item):
+        return
+
+    finished_evaluating = has_finished_required_evaluating(
+        StudentItemSerializer(student_item).data,
+        required_assessments_for_student
+    )
+    assessments = Assessment.objects.filter(submission=submission, score_type=PEER_TYPE)
+    submission_finished = assessments.count() >= must_be_graded_by
+
+    if finished_evaluating and submission_finished:
+        submission_api.set_score(
+            StudentItemSerializer(student_item).data,
+            SubmissionSerializer(submission).data,
+            sum(get_assessment_median_scores(submission.uuid, must_be_graded_by).values()),
+            assessments[0].points_possible
+        )
+
+
 def get_assessment_median_scores(submission_id, must_be_graded_by):
     """Get the median score for each rubric criterion
 
@@ -289,7 +323,8 @@ def has_finished_required_evaluating(student_item_dict, required_assessments):
     )
     count = Assessment.objects.filter(
         submission__in=submissions,
-        scorer_id=student_item_dict["student_id"]
+        scorer_id=student_item_dict["student_id"],
+        score_type=PEER_TYPE
     ).count()
     return count >= required_assessments, count
 
@@ -418,7 +453,7 @@ def _get_first_submission_not_evaluated(student_items, student_id, required_num_
         "-attempt_number"
     )
     for submission in submissions:
-        assessments = Assessment.objects.filter(submission=submission)
+        assessments = Assessment.objects.filter(submission=submission, score_type=PEER_TYPE)
         if assessments.count() < required_num_assessments:
             already_evaluated = False
             for assessment in assessments:

apps/openassessment/assessment/self_api.py

+"""
+Public interface for self-assessment.
+"""
+from django.utils.translation import ugettext as _
+from submissions.api import (
+    get_submission_by_uuid, get_submissions,
+    SubmissionNotFoundError, SubmissionRequestError
+)
+from openassessment.assessment.serializers import (
+    rubric_from_dict, AssessmentSerializer, full_assessment_dict, InvalidRubric
+)
+from openassessment.assessment.models import Assessment, InvalidOptionSelection
+
+# TODO -- remove once Dave's changes land
+from submissions.models import Submission
+
+
+# Assessments are tagged as "self-evaluation"
+SELF_TYPE = "SE"
+
+
+class SelfAssessmentRequestError(Exception):
+    """
+    There was a problem with the request for a self-assessment.
+    """
+    pass
+
+
+def create_assessment(submission_uuid, user_id, options_selected, rubric_dict, scored_at=None):
+    """
+    Create a self-assessment for a submission.
+
+    Args:
+        submission_uuid (str): The unique identifier for the submission being assessed.
+        user_id (str): The ID of the user creating the assessment.  This must match the ID of the user who made the submission.
+        options_selected (dict): Mapping of rubric criterion names to option values selected.
+        rubric_dict (dict): Serialized Rubric model.
+
+    Kwargs:
+        scored_at (datetime): The timestamp of the assessment; defaults to the current time.
+
+    Returns:
+        dict: serialized Assessment model
+
+    Raises:
+        SelfAssessmentRequestError: Could not retrieve a submission that the user is allowed to score.
+    """
+    # Check that there are not any assessments for this submission
+    # TODO -- change key lookup for submission UUID once Dave's changes land
+    if Assessment.objects.filter(submission__uuid=submission_uuid, score_type=SELF_TYPE).exists():
+        raise SelfAssessmentRequestError(_("Self assessment already exists for this submission"))
+
+    # Check that the student is allowed to assess this submission
+    try:
+        submission = get_submission_by_uuid(submission_uuid)
+        if submission is None or submission['student_item']['student_id'] != user_id:
+            raise SelfAssessmentRequestError(_("Cannot self-assess this submission"))
+    except SubmissionNotFoundError:
+        raise SelfAssessmentRequestError(_("Could not retrieve the submission."))
+
+    # Get or create the rubric
+    try:
+        rubric = rubric_from_dict(rubric_dict)
+        option_ids = rubric.options_ids(options_selected)
+    except InvalidRubric as ex:
+        msg = _("Invalid rubric definition: {errors}").format(errors=ex.errors)
+        raise SelfAssessmentRequestError(msg)
+    except InvalidOptionSelection:
+        msg = _("Selected options do not match the rubric")
+        raise SelfAssessmentRequestError(msg)
+
+    # Create the assessment
+    # Since we have already retrieved the submission, we can assume that
+    # the user who created the submission exists.
+    self_assessment = {
+        "rubric": rubric.id,
+        "scorer_id": user_id,
+        # TODO -- replace once Dave adds submission_uuid as a field on the assessment
+        "submission": Submission.objects.get(uuid=submission_uuid).pk,
+        "score_type": SELF_TYPE,
+        "feedback": u"",
+        "parts": [{"option": option_id} for option_id in option_ids],
+    }
+
+    if scored_at is not None:
+        self_assessment['scored_at'] = scored_at
+
+    # Serialize the assessment
+    serializer = AssessmentSerializer(data=self_assessment)
+    if not serializer.is_valid():
+        msg = _("Could not create self assessment: {errors}").format(errors=serializer.errors)
+        raise SelfAssessmentRequestError(msg)
+
+    serializer.save()
+
+    # Return the serialized assessment
+    return serializer.data
+
+
+def get_submission_and_assessment(student_item_dict):
+    """
+    Retrieve a submission and self-assessment for a student item.
+
+    Args:
+        student_item_dict (dict): serialized StudentItem model
+
+    Returns:
+        A tuple `(submission, assessment)` where:
+            submission (dict) is a serialized Submission model, or None (if the user has not yet made a submission)
+            assessment (dict) is a serialized Assessment model, or None (if the user has not yet self-assessed)
+
+        If multiple submissions or self-assessments are found, returns the most recent one.
+
+    Raises:
+        SelfAssessmentRequestError: Student item dict was invalid.
+    """
+    # Look up the most recent submission from the student item
+    try:
+        submissions = get_submissions(student_item_dict, limit=1)
+        if not submissions:
+            return (None, None)
+    except SubmissionNotFoundError:
+        return (None, None)
+    except SubmissionRequestError as ex:
+        raise SelfAssessmentRequestError(_('Could not retrieve submission'))
+
+    submission_uuid = submissions[0]['uuid']
+
+    # Retrieve assessments for the submission
+    # We weakly enforce that number of self-assessments per submission is <= 1,
+    # but not at the database level.  Someone could take advantage of the race condition
+    # between checking the number of self-assessments and creating a new self-assessment.
+    # To be safe, we retrieve just the most recent submission.
+    assessments = Assessment.objects.filter(
+        score_type=SELF_TYPE, submission__uuid=submission_uuid
+    ).order_by('-scored_at')
+
+    if assessments.exists():
+        # TODO -- remove once Dave's changes land
+        assessment_dict = full_assessment_dict(assessments[0])
+        assessment_dict['submission_uuid'] = submission_uuid
+        return (submissions[0], assessment_dict)
+    else:
+        return (submissions[0], None)
+
+
+# TODO: fill in this stub
+def is_complete(submission_uuid):
+    return True

apps/openassessment/peer/serializers.py → apps/openassessment/assessment/serializers.py

@@ -8,7 +8,7 @@ from copy import deepcopy
 import dateutil.parser
 from django.utils.translation import ugettext as _
 from rest_framework import serializers
-from openassessment.peer.models import (
+from openassessment.assessment.models import (
     Assessment, AssessmentPart, Criterion, CriterionOption, Rubric
 )
 
@@ -123,7 +123,7 @@ class AssessmentSerializer(serializers.ModelSerializer):
             'scored_at',
             'scorer_id',
             'score_type',
-            'feedback', 
+            'feedback',
 
             # Foreign Key
             'parts',
@@ -153,7 +153,7 @@ def get_assessment_review(submission):
 
     Examples:
         >>> get_assessment_review(submission)
-        {
+        [{
             'submission': 1,
             'rubric': {
                 'id': 1,
@@ -183,26 +183,38 @@ def get_assessment_review(submission):
             'submission_uuid': u'0a600160-be7f-429d-a853-1283d49205e7',
             'points_earned': 9,
             'points_possible': 20,
-        }
+        }]
+    """
+    return [
+        full_assessment_dict(assessment)
+        for assessment in Assessment.objects.filter(submission=submission)
+    ]
+
+
+def full_assessment_dict(assessment):
     """
-    reviews = []
-    assessments = Assessment.objects.filter(submission=submission)
-    for assessment in assessments:
-        assessment_dict = AssessmentSerializer(assessment).data
-        rubric_dict = RubricSerializer(assessment.rubric).data
-        assessment_dict["rubric"] = rubric_dict
-        parts = []
-        for part in assessment.parts.all():
-            part_dict = AssessmentPartSerializer(part).data
-            options_dict = CriterionOptionSerializer(part.option).data
-            criterion_dict = CriterionSerializer(part.option.criterion).data
-            options_dict["criterion"] = criterion_dict
-            part_dict["option"] = options_dict
-            parts.append(part_dict)
-        assessment_dict["parts"] = parts
-        reviews.append(assessment_dict)
-    return reviews
+    Return a dict representation of the Assessment model,
+    including nested assessment parts.
+
+    Args:
+        assessment (Assessment): The Assessment model to serialize
 
+    Returns:
+        dict with keys 'rubric' (serialized Rubric model) and 'parts' (serialized assessment parts)
+    """
+    assessment_dict = AssessmentSerializer(assessment).data
+    rubric_dict = RubricSerializer(assessment.rubric).data
+    assessment_dict["rubric"] = rubric_dict
+    parts = []
+    for part in assessment.parts.all():
+        part_dict = AssessmentPartSerializer(part).data
+        options_dict = CriterionOptionSerializer(part.option).data
+        criterion_dict = CriterionSerializer(part.option.criterion).data
+        options_dict["criterion"] = criterion_dict
+        part_dict["option"] = options_dict
+        parts.append(part_dict)
+    assessment_dict["parts"] = parts
+    return assessment_dict
 
 
 def rubric_from_dict(rubric_dict):
@@ -276,18 +288,27 @@ def validate_assessment_dict(assessment_dict):
     if not assessment_dict.get('name') in ['peer-assessment', 'self-assessment']:
         return (False, _("Assessment type is not supported"))
 
-    # Number you need to grade is >= the number of people that need to grade you
-    must_grade = assessment_dict.get('must_grade')
-    must_be_graded_by = assessment_dict.get('must_be_graded_by')
+    # Peer assessments need to specify must_grade and must_be_graded_by
+    if assessment_dict.get('name') == 'peer-assessment':
+
+        if 'must_grade' not in assessment_dict:
+            return (False, _(u'Attribute "must_grade" is missing from peer assessment.'))
+
+        if 'must_be_graded_by' not in assessment_dict:
+            return (False, _(u'Attribute "must_be_graded_by" is missing from peer assessment.'))
+
+        # Number you need to grade is >= the number of people that need to grade you
+        must_grade = assessment_dict.get('must_grade')
+        must_be_graded_by = assessment_dict.get('must_be_graded_by')
 
-    if must_grade is None or must_grade < 1:
-        return (False, _('"must_grade" must be a positive integer'))
+        if must_grade is None or must_grade < 1:
+            return (False, _('"must_grade" must be a positive integer'))
 
-    if must_be_graded_by is None or must_be_graded_by < 1:
-        return (False, _('"must_be_graded_by" must be a positive integer'))
+        if must_be_graded_by is None or must_be_graded_by < 1:
+            return (False, _('"must_be_graded_by" must be a positive integer'))
 
-    if must_grade < must_be_graded_by:
-        return (False, _('"must_grade" should be greater than or equal to "must_be_graded_by"'))
+        if must_grade < must_be_graded_by:
+            return (False, _('"must_grade" should be greater than or equal to "must_be_graded_by"'))
 
     return (True, u'')
 

apps/openassessment/peer/test/data/invalid_assessments.json → apps/openassessment/assessment/test/data/invalid_assessments.json

@@ -50,14 +50,14 @@
     },
     "must_grade_zero": {
         "assessment": {
-            "name": "self-assessment",
+            "name": "peer-assessment",
             "must_grade": 0,
             "must_be_graded_by": 0
         }
     },
     "must_be_graded_by_zero": {
         "assessment": {
-            "name": "self-assessment",
+            "name": "peer-assessment",
             "must_grade": 1,
             "must_be_graded_by": 0
         }

apps/openassessment/assessment/test/test_models.py

+"""
+Tests for assessment models.
+"""
+
+from django.test import TestCase
+from openassessment.assessment.models import (
+    Rubric, Criterion, CriterionOption, InvalidOptionSelection
+)
+
+
+class TestRubricOptionIds(TestCase):
+    """
+    Test selection of options from a rubric.
+    """
+
+    NUM_CRITERIA = 4
+    NUM_OPTIONS = 3
+
+    def setUp(self):
+        """
+        Create a rubric in the database.
+        """
+        self.rubric = Rubric.objects.create()
+        self.criteria = [
+            Criterion.objects.create(
+                rubric=self.rubric,
+                name="test criterion {num}".format(num=num),
+                order_num=num,
+            ) for num in range(self.NUM_CRITERIA)
+        ]
+
+        self.options = dict()
+        for criterion in self.criteria:
+            self.options[criterion.name] = [
+                CriterionOption.objects.create(
+                    criterion=criterion,
+                    name="test option {num}".format(num=num),
+                    order_num=num,
+                    points=num
+                ) for num in range(self.NUM_OPTIONS)
+            ]
+
+    def test_option_ids(self):
+        options_ids = self.rubric.options_ids({
+            "test criterion 0": "test option 0",
+            "test criterion 1": "test option 1",
+            "test criterion 2": "test option 2",
+            "test criterion 3": "test option 0",
+        })
+        self.assertEqual(options_ids, set([
+            self.options['test criterion 0'][0].id,
+            self.options['test criterion 1'][1].id,
+            self.options['test criterion 2'][2].id,
+            self.options['test criterion 3'][0].id
+        ]))
+
+    def test_option_ids_different_order(self):
+        options_ids = self.rubric.options_ids({
+            "test criterion 0": "test option 0",
+            "test criterion 1": "test option 1",
+            "test criterion 2": "test option 2",
+            "test criterion 3": "test option 0",
+        })
+        self.assertEqual(options_ids, set([
+            self.options['test criterion 0'][0].id,
+            self.options['test criterion 1'][1].id,
+            self.options['test criterion 2'][2].id,
+            self.options['test criterion 3'][0].id
+        ]))
+
+    def test_option_ids_missing_criteria(self):
+        with self.assertRaises(InvalidOptionSelection):
+            self.rubric.options_ids({
+                "test criterion 0": "test option 0",
+                "test criterion 1": "test option 1",
+                "test criterion 3": "test option 2",
+            })
+
+    def test_option_ids_extra_criteria(self):
+        with self.assertRaises(InvalidOptionSelection):
+            self.rubric.options_ids({
+                "test criterion 0": "test option 0",
+                "test criterion 1": "test option 1",
+                "test criterion 2": "test option 2",
+                "test criterion 3": "test option 1",
+                "extra criterion": "test",
+            })
+
+    def test_option_ids_mutated_criterion_name(self):
+        with self.assertRaises(InvalidOptionSelection):
+            self.rubric.options_ids({
+                "test mutated criterion": "test option 1",
+                "test criterion 1": "test option 1",
+                "test criterion 2": "test option 2",
+                "test criterion 3": "test option 1",
+            })
+
+    def test_option_ids_mutated_option_name(self):
+        with self.assertRaises(InvalidOptionSelection):
+            self.rubric.options_ids({
+                "test criterion 0": "test option 1",
+                "test criterion 1": "test mutated option",
+                "test criterion 2": "test option 2",
+                "test criterion 3": "test option 1",
+            })

apps/openassessment/peer/test/test_api.py → apps/openassessment/assessment/test/test_peer.py

@@ -9,8 +9,8 @@ from ddt import ddt, file_data
 from mock import patch
 from nose.tools import raises
 
-from openassessment.peer import api as peer_api
-from openassessment.peer.models import Assessment
+from openassessment.assessment import peer_api
+from openassessment.assessment.models import Assessment
 from openassessment.workflow import api as workflow_api
 from submissions import api as sub_api
 from submissions.models import Submission

apps/openassessment/assessment/test/test_self.py

+# -*- coding: utf-8 -*-
+"""
+Tests for self-assessment API.
+"""
+
+import copy
+import datetime
+import pytz
+from django.test import TestCase
+from submissions.api import create_submission
+from openassessment.assessment.self_api import (
+    create_assessment, get_submission_and_assessment,
+    SelfAssessmentRequestError
+)
+
+
+class TestSelfApi(TestCase):
+
+    STUDENT_ITEM = {
+        'student_id': u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+        'item_id': 'test_item',
+        'course_id': 'test_course',
+        'item_type': 'test_type'
+    }
+
+    RUBRIC = {
+        "criteria": [
+            {
+                "name": "clarity",
+                "prompt": "How clear was it?",
+                "options": [
+                    {"name": "somewhat clear", "points": 1, "explanation": ""},
+                    {"name": "clear", "points": 3, "explanation": ""},
+                    {"name": "very clear", "points": 5, "explanation": ""},
+                ]
+            },
+            {
+                "name": "accuracy",
+                "prompt": "How accurate was the content?",
+                "options": [
+                    {"name": "somewhat accurate", "points": 1, "explanation": ""},
+                    {"name": "accurate", "points": 3, "explanation": ""},
+                    {"name": "very accurate", "points": 5, "explanation": ""},
+                ]
+            },
+        ]
+    }
+
+    OPTIONS_SELECTED = {
+        "clarity": "clear",
+        "accuracy": "very accurate",
+    }
+
+    def test_create_assessment(self):
+        # Initially, there should be no submission or self assessment
+        self.assertEqual(get_submission_and_assessment(self.STUDENT_ITEM), (None, None))
+
+        # Create a submission to self-assess
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Now there should be a submission, but no self-assessment
+        received_submission, assessment = get_submission_and_assessment(self.STUDENT_ITEM)
+        self.assertItemsEqual(received_submission, submission)
+        self.assertIs(assessment, None)
+
+        # Create a self-assessment for the submission
+        assessment = create_assessment(
+            submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+            self.OPTIONS_SELECTED, self.RUBRIC,
+            scored_at=datetime.datetime(2014, 4, 1).replace(tzinfo=pytz.utc)
+        )
+
+        # Retrieve the self-assessment
+        received_submission, retrieved = get_submission_and_assessment(self.STUDENT_ITEM)
+        self.assertItemsEqual(received_submission, submission)
+
+        # Check that the assessment we created matches the assessment we retrieved
+        # and that both have the correct values
+        self.assertItemsEqual(assessment, retrieved)
+        self.assertEqual(assessment['submission_uuid'], submission['uuid'])
+        self.assertEqual(assessment['points_earned'], 8)
+        self.assertEqual(assessment['points_possible'], 10)
+        self.assertEqual(assessment['feedback'], u'')
+        self.assertEqual(assessment['score_type'], u'SE')
+
+    def test_create_assessment_no_submission(self):
+        # Attempt to create a self-assessment for a submission that doesn't exist
+        with self.assertRaises(SelfAssessmentRequestError):
+            create_assessment(
+                'invalid_submission_uuid', u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+                self.OPTIONS_SELECTED, self.RUBRIC,
+                scored_at=datetime.datetime(2014, 4, 1)
+            )
+
+    def test_create_assessment_wrong_user(self):
+        # Create a submission
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Attempt to create a self-assessment for the submission from a different user
+        with self.assertRaises(SelfAssessmentRequestError):
+            create_assessment(
+                'invalid_submission_uuid', u'another user',
+                self.OPTIONS_SELECTED, self.RUBRIC,
+                scored_at=datetime.datetime(2014, 4, 1)
+            )
+
+    def test_create_assessment_invalid_criterion(self):
+        # Create a submission
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Mutate the selected option criterion so it does not match a criterion in the rubric
+        options = copy.deepcopy(self.OPTIONS_SELECTED)
+        options['invalid criterion'] = 'very clear'
+
+        # Attempt to create a self-assessment with options that do not match the rubric
+        with self.assertRaises(SelfAssessmentRequestError):
+            create_assessment(
+                submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+                options, self.RUBRIC,
+                scored_at=datetime.datetime(2014, 4, 1)
+            )
+
+    def test_create_assessment_invalid_option(self):
+        # Create a submission
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Mutate the selected option so the value does not match an available option
+        options = copy.deepcopy(self.OPTIONS_SELECTED)
+        options['clarity'] = 'invalid option'
+
+        # Attempt to create a self-assessment with options that do not match the rubric
+        with self.assertRaises(SelfAssessmentRequestError):
+            create_assessment(
+                submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+                options, self.RUBRIC,
+                scored_at=datetime.datetime(2014, 4, 1)
+            )
+
+    def test_create_assessment_missing_critieron(self):
+        # Create a submission
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Delete one of the criterion that's present in the rubric
+        options = copy.deepcopy(self.OPTIONS_SELECTED)
+        del options['clarity']
+
+        # Attempt to create a self-assessment with options that do not match the rubric
+        with self.assertRaises(SelfAssessmentRequestError):
+            create_assessment(
+                submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+                options, self.RUBRIC,
+                scored_at=datetime.datetime(2014, 4, 1)
+            )
+
+    def test_create_assessment_timestamp(self):
+        # Create a submission to self-assess
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Record the current system clock time
+        before = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
+
+        # Create a self-assessment for the submission
+        # Do not override the scored_at timestamp, so it should be set to the current time
+        assessment = create_assessment(
+            submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+            self.OPTIONS_SELECTED, self.RUBRIC,
+        )
+
+        # Retrieve the self-assessment
+        _, retrieved = get_submission_and_assessment(self.STUDENT_ITEM)
+
+        # Expect that both the created and retrieved assessments have the same
+        # timestamp, and it's >= our recorded time.
+        self.assertEqual(assessment['scored_at'], retrieved['scored_at'])
+        self.assertGreaterEqual(assessment['scored_at'], before)
+
+    def test_create_multiple_self_assessments(self):
+        # Create a submission to self-assess
+        submission = create_submission(self.STUDENT_ITEM, "Test answer")
+
+        # Self assess once
+        assessment = create_assessment(
+            submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+            self.OPTIONS_SELECTED, self.RUBRIC,
+        )
+
+        # Attempt to self-assess again, which should raise an exception
+        with self.assertRaises(SelfAssessmentRequestError):
+            create_assessment(
+                submission['uuid'], u'𝖙𝖊𝖘𝖙 𝖚𝖘𝖊𝖗',
+                self.OPTIONS_SELECTED, self.RUBRIC,
+            )
+
+        # Expect that we still have the original assessment
+        _, retrieved = get_submission_and_assessment(self.STUDENT_ITEM)
+        self.assertItemsEqual(assessment, retrieved)

apps/openassessment/peer/test/test_serializers.py → apps/openassessment/assessment/test/test_serializers.py

@@ -4,8 +4,8 @@ import os.path
 from ddt import ddt, file_data
 from django.test import TestCase
 
-from openassessment.peer.models import Criterion, CriterionOption, Rubric
-from openassessment.peer.serializers import (
+from openassessment.assessment.models import Criterion, CriterionOption, Rubric
+from openassessment.assessment.serializers import (
     InvalidRubric, RubricSerializer, rubric_from_dict
 )
 

apps/openassessment/peer/test/test_validation.py → apps/openassessment/assessment/test/test_validation.py

@@ -4,7 +4,7 @@ Test validation of serialized models.
 
 import ddt
 from django.test import TestCase
-from openassessment.peer.serializers import validate_assessment_dict, validate_rubric_dict
+from openassessment.assessment.serializers import validate_assessment_dict, validate_rubric_dict
 
 
 @ddt.ddt

apps/openassessment/peer/urls.py → apps/openassessment/assessment/urls.py

 from django.conf.urls import patterns, url
 
 urlpatterns = patterns(
-    'openassessment.peer.views',
+    'openassessment.assessment.views',
     url(
         r'^(?P<student_id>[^/]+)/(?P<course_id>[^/]+)/(?P<item_id>[^/]+)$',
         'get_evaluations_for_student_item'

apps/openassessment/peer/views.py → apps/openassessment/assessment/views.py

@@ -2,7 +2,7 @@ import logging
 from django.contrib.auth.decorators import login_required
 
 from django.shortcuts import render_to_response
-from openassessment.peer.api import get_assessments
+from openassessment.assessment.peer_api import get_assessments
 from submissions.api import SubmissionRequestError, get_submissions
 
 log = logging.getLogger(__name__)

apps/openassessment/templates/openassessmentblock/oa_error.html

+<!-- TODO: this is a placeholder -->
+<div>{{ error_msg }}</div>

apps/openassessment/templates/openassessmentblock/self/oa_self_assessment.html

+{% load i18n %}
+
 {% block list_item %}
 <li id="openassessment__self-assessment" class="openassessment__steps__step step--self-assessment is--expanded">
 {% endblock %}
+    <span class="system__element" id="self_submission_uuid">
+        {{ self_submission.uuid }}
+    </span>
 
     <header class="step__header ui-toggle-visibility__control">
         <h2 class="step__title">
@@ -69,13 +74,6 @@
                         </li>
                         {% endfor %}
 
-                        <li class="wrapper--input field field--textarea assessment__rubric__question" id="assessment__rubric__question--feedback">
-                            <label for="assessment__rubric__question--feedback__value">
-                                <i class="ico fa fa-caret-right"></i>
-                                <span class="question__title__copy">Please provide any other feedback you have around this response</span>
-                            </label>
-                            <textarea id="assessment__rubric__question--feedback__value" placeholder="I felt this response was..."></textarea>
-                        </li>
                     </ol>
                 </fieldset>
 
@@ -83,7 +81,7 @@
                     <ul class="list list--actions">
                         <li class="list--actions__item">
                             <button type="submit" id="self-assessment--001__assessment__submit" class="action action--submit">
-                                <span class="copy">{{ submit_button_text }}</span>
+                                <span class="copy">{% trans "Submit Your Assessment" %}</span>
                                 <i class="ico fa fa-arrow-right"></i>
                             </button>
                         </li>

apps/openassessment/workflow/models.py

@@ -9,10 +9,10 @@ from django_extensions.db.fields import UUIDField
 from model_utils import Choices
 from model_utils.models import StatusModel, TimeStampedModel
 
-from openassessment.peer import api as peer_api
-from openassessment.peer import self_api
+from openassessment.assessment import peer_api, self_api
 from submissions import api as sub_api
 
+
 class AssessmentWorkflow(TimeStampedModel, StatusModel):
     """Tracks the open-ended assessment status of a student submission.
 

apps/openassessment/xblock/grade_mixin.py

 from xblock.core import XBlock
-from openassessment.peer import api as peer_api
+from openassessment.assessment.peer_api import get_assessments
 from openassessment.workflow import api as workflow_api
 
 
@@ -25,7 +25,7 @@ class GradeMixin(object):
                 "score": workflow["score"],
                 "assessments": [
                     assessment
-                    for assessment in peer_api.get_assessments(self.submission_uuid)
+                    for assessment in get_assessments(self.submission_uuid)
                 ],
             }
         elif workflow.get('status') == "waiting":

apps/openassessment/xblock/openassessmentblock.py

@@ -360,6 +360,20 @@ class OpenAssessmentBlock(
         context = Context(context_dict)
         return Response(template.render(context), content_type='application/html', charset='UTF-8')
 
+    def render_error(self, error_msg):
+        """
+        Render an error message.
+
+        Args:
+            error_msg (unicode): The error message to display.
+
+        Returns:
+            Response: A response object with an HTML body.
+        """
+        context = Context({'error_msg': error_msg})
+        template = get_template('openassessmentblock/oa_error.html')
+        return Response(template.render(context), content_type='application/html', charset='UTF-8')
+
     def is_open(self):
         """Checks if the question is open.
 

apps/openassessment/xblock/peer_assessment_mixin.py

 import logging
 from django.utils.translation import ugettext as _
 from xblock.core import XBlock
-from openassessment.peer import api as peer_api
-from openassessment.peer.api import (
+from openassessment.assessment import peer_api
+from openassessment.assessment.peer_api import (
         PeerAssessmentWorkflowError, PeerAssessmentRequestError,
         PeerAssessmentInternalError
 )
@@ -25,8 +25,8 @@ class PeerAssessmentMixin(object):
     """
 
     @XBlock.json_handler
-    def assess(self, data, suffix=''):
-        """Place an assessment into OpenAssessment system
+    def peer_assess(self, data, suffix=''):
+        """Place a peer assessment into OpenAssessment system
 
         Assess a Peer Submission.  Performs basic workflow validation to ensure
         that an assessment can be performed as this time.

apps/openassessment/xblock/self_assessment_mixin.py

+import logging
+from django.utils.translation import ugettext as _
+
 from xblock.core import XBlock
+from openassessment.assessment import self_api
+
+
+logger = logging.getLogger(__name__)
 
 
 class SelfAssessmentMixin(object):
     """The Self Assessment Mixin for all Self Assessment Functionality.
 
     Abstracts all functionality and handlers associated with Self Assessment.
-    All Self Assessment API calls should be contained without this Mixin as
+    All Self Assessment API calls should be contained within this Mixin as
     well.
 
     SelfAssessmentMixin is a Mixin for the OpenAssessmentBlock. Functions in
     the SelfAssessmentMixin call into the OpenAssessmentBlock functions and
     will not work outside of OpenAssessmentBlock.
-
     """
 
     @XBlock.handler
     def render_self_assessment(self, data, suffix=''):
+        student = self.get_student_item_dict()
         path = 'openassessmentblock/self/oa_self_closed.html'
-        context_dict = {}
-        student_item = self.get_student_item_dict()
-        student_submission = self.get_user_submission(student_item)
-        if student_submission:
-            path = 'openassessmentblock/self/oa_self_assessment.html'
-            context_dict = {
-                "rubric_criteria": self.rubric_criteria,
-                "estimated_time": "20 minutes",  # TODO: Need to configure this.
-                "self_submission": student_submission,
-                "step_status": "Grading"
-            }
-        return self.render_assessment(path, context_dict)
+        context = {"step_status": "Incomplete"}
+
+        # If we are not logged in (as in Studio preview mode),
+        # we cannot interact with the self-assessment API.
+        if student['student_id'] is not None:
+
+            # Retrieve the self-assessment, if there is one
+            try:
+                submission, assessment = self_api.get_submission_and_assessment(student)
+            except self_api.SelfAssessmentRequestError:
+                logger.exception(u"Could not retrieve self assessment for {student_item}".format(student_item=student))
+                return self.render_error(_(u"An unexpected error occurred."))
+
+            # If we haven't submitted yet, we cannot self-assess
+            if submission is None:
+                path = 'openassessmentblock/self/oa_self_closed.html'
+                context = {"step_status": "Incomplete"}
+
+            # If we have already submitted, then we're complete
+            elif assessment is not None:
+                path = 'openassessmentblock/self/oa_self_complete.html'
+                context = {"step_status": "Complete"}
+
+            # Otherwise, we can submit a self-assessment
+            else:
+                path = 'openassessmentblock/self/oa_self_assessment.html'
+                context = {
+                    "rubric_criteria": self.rubric_criteria,
+                    "estimated_time": "20 minutes",  # TODO: Need to configure this.
+                    "self_submission": submission,
+                    "step_status": "Grading"
+                }
+
+        return self.render_assessment(path, context)
+
+    @XBlock.json_handler
+    def self_assess(self, data, suffix=''):
+        """
+        Create a self-assessment for a submission.
+
+        Args:
+            data (dict): Must have the following keys:
+                submission_uuid (string): The unique identifier of the submission being assessed.
+                options_selected (dict): Dictionary mapping criterion names to option values.
+
+        Returns:
+            Dict with keys "success" (bool) indicating success/failure
+            and "msg" (unicode) containing additional information if an error occurs.
+        """
+        if 'submission_uuid' not in data:
+            return {'success': False, 'msg': _(u"Missing submission_uuid key in request")}
+        if 'options_selected' not in data:
+            return {'success': False, 'msg': _(u"Missing options_selected key in request")}
+
+        try:
+            self_api.create_assessment(
+                data['submission_uuid'],
+                self.get_student_item_dict()['student_id'],
+                data['options_selected'],
+                {"criteria": self.rubric_criteria}
+            )
+        except self_api.SelfAssessmentRequestError as ex:
+            msg = _(u"Could not create self assessment: {error}").format(error=ex.message)
+            return {'success': False, 'msg': msg}
+        else:
+            return {'success': True, 'msg': u""}

apps/openassessment/xblock/static/js/fixtures/oa_base.html

+<div id="openassessment-base">
+    <div id="openassessment__response"></div>
+    <div id="openassessment__peer-assessment"></div>
+    <div id="openassessment__self-assessment"></div>
+    <div id="openassessment__self-assessment"></div>
+    <div id="openassessment__grade"></div>
+</div>

apps/openassessment/xblock/static/js/fixtures/peer_assessment_frag.html

+<span id="peer_submission_uuid">abc1234</span>
+<div id="peer-assessment--001__assessment">
+    <input name="option 1" type="radio" />
+    <input name="option 2" type="radio" />
+    <input name="option 3" type="radio" />
+</div>
+<div id="assessment__rubric__question--feedback__value">test feedback</div>

apps/openassessment/xblock/static/js/fixtures/self_assessment_frag.html

+<span id="self_submission_uuid">abc1234</span>
+<div id="self-assessment--001__assessment">
+    <input name="option 1" type="radio" />
+    <input name="option 2" type="radio" />
+    <input name="option 3" type="radio" />
+</div>

apps/openassessment/xblock/static/js/spec/oa_base.js

+/**
+Tests for OA student-facing views.
+**/
+
+describe("OpenAssessment.BaseUI", function() {
+
+    // Stub server that returns dummy data
+    var StubServer = function() {
+
+        // Dummy fragments to return from the render func
+        this.fragments = {
+            submission: "Test submission",
+            self_assessment: readFixtures("self_assessment_frag.html"),
+            peer_assessment: readFixtures("peer_assessment_frag.html"),
+            grade: "Test fragment"
+        };
+
+        this.submit = function(submission) {
+            return $.Deferred(function(defer) {
+                 defer.resolveWith(this, ['student', 0]);
+            }).promise();
+        };
+
+        this.peerAssess = function(submissionId, optionsSelected, feedback) {
+            return $.Deferred(function(defer) { defer.resolve(); }).promise();
+        };
+
+        this.selfAssess = function(submissionId, optionsSelected) {
+            return $.Deferred(function(defer) { defer.resolve(); }).promise();
+        };
+
+        this.render = function(component) {
+            var server = this;
+            return $.Deferred(function(defer) {
+                defer.resolveWith(this, [server.fragments[component]]);
+            }).promise();
+        };
+    }
+
+    // Stub runtime
+    var runtime = {};
+
+    var server = null;
+    var ui = null;
+
+    /**
+    Wait for subviews to load before executing callback.
+
+    Args:
+        callback (function): Function that takes no arguments.
+    **/
+    var loadSubviews = function(callback) {
+        runs(function() {
+            ui.load();
+        });
+
+        waitsFor(function() {
+            var subviewHasHtml = $("#openassessment-base").children().map(
+                function(index, el) { return el.innerHTML != ''; }
+            );
+            return Array(subviewHasHtml).every(function(hasHtml) { return hasHtml; });
+        });
+
+        runs(function() {
+            return callback();
+        });
+    }
+
+    beforeEach(function() {
+        // Load the DOM fixture
+        jasmine.getFixtures().fixturesPath = 'base/fixtures'
+        loadFixtures('oa_base.html');
+
+        // Create a new stub server
+        server = new StubServer();
+
+        // Create the object under test
+        var el = $("#openassessment-base").get(0);
+        ui = new OpenAssessment.BaseUI(runtime, el, server);
+    });
+
+    it("Sends a submission to the server", function() {
+        loadSubviews(function() {
+            spyOn(server, 'submit').andCallThrough();
+            ui.submit();
+            expect(server.submit).toHaveBeenCalled();
+        });
+    });
+
+    it("Sends a peer assessment to the server", function() {
+        loadSubviews(function() {
+            spyOn(server, 'peerAssess').andCallThrough();
+            ui.peerAssess();
+            expect(server.peerAssess).toHaveBeenCalled()
+        });
+    });
+
+    it("Sends a self assessment to the server", function() {
+        loadSubviews(function() {
+            spyOn(server, 'selfAssess').andCallThrough();
+            ui.selfAssess();
+            expect(server.selfAssess).toHaveBeenCalled();
+        });
+    });
+});

apps/openassessment/xblock/static/js/spec/oa_server.js

@@ -90,13 +90,13 @@ describe("OpenAssessment.Server", function() {
 
         var success = false;
         var options = {clarity: "Very clear", precision: "Somewhat precise"};
-        server.assess("abc1234", options, "Excellent job!").done(function() {
+        server.peerAssess("abc1234", options, "Excellent job!").done(function() {
             success = true;
         });
 
         expect(success).toBe(true);
         expect($.ajax).toHaveBeenCalledWith({
-            url: '/assess',
+            url: '/peer_assess',
             type: "POST",
             data: JSON.stringify({
                 submission_uuid: "abc1234",
@@ -231,24 +231,24 @@ describe("OpenAssessment.Server", function() {
         expect(receivedMsg).toEqual("Test error");
     });
 
-    it("informs the caller of a server error when sending an assessment", function() {
+    it("informs the caller of a server error when sending a peer assessment", function() {
         stubAjax(true, {success:false, msg:'Test error!'});
 
         var receivedMsg = null;
-        var options = {clarity: "Very clear", precision: "Somewhat precise"};
-        server.assess("abc1234", options, "Excellent job!").fail(function(msg) {
+        var options = {clarity: "Very clear", precision: "Somewhat precise"}
+        server.peerAssess("abc1234", options, "Excellent job!").fail(function(msg) {
             receivedMsg = msg;
         });
 
         expect(receivedMsg).toEqual("Test error!");
     });
 
-    it("informs the caller of an AJAX error when sending an assessment", function() {
+    it("informs the caller of an AJAX error when sending a peer assessment", function() {
         stubAjax(false, null);
 
         var receivedMsg = null;
-        var options = {clarity: "Very clear", precision: "Somewhat precise"};
-        server.assess("abc1234", options, "Excellent job!").fail(function(msg) {
+        var options = {clarity: "Very clear", precision: "Somewhat precise"}
+        server.peerAssess("abc1234", options, "Excellent job!").fail(function(msg) {
             receivedMsg = msg;
         });
 

apps/openassessment/xblock/static/js/src/oa_base.js

@@ -111,7 +111,7 @@ OpenAssessment.BaseUI.prototype = {
                         eventObject.preventDefault();
 
                         // Handle the click
-                        ui.assess();
+                        ui.peerAssess();
                     }
                 );
             }
@@ -133,6 +133,17 @@ OpenAssessment.BaseUI.prototype = {
             function(html) {
                 $('#openassessment__self-assessment', ui.element).replaceWith(html);
                 ui.setExpanded('self-assessment', expand);
+
+                // Install a click handler for the submit button
+                $('#self-assessment--001__assessment__submit', ui.element).click(
+                    function(eventObject) {
+                        // Override default form submission
+                        eventObject.preventDefault();
+
+                        // Handle the click
+                        ui.selfAssess();
+                    }
+                );
             }
         ).fail(function(errMsg) {
             // TODO: display to the user
@@ -198,11 +209,11 @@ OpenAssessment.BaseUI.prototype = {
     /**
     Send an assessment to the server and update the UI.
     **/
-    assess: function() {
+    peerAssess: function() {
         // Retrieve assessment info from the DOM
         var submissionId = $("span#peer_submission_uuid", this.element)[0].innerText;
         var optionsSelected = {};
-        $("input[type=radio]:checked", this.element).each(
+        $("#peer-assessment--001__assessment input[type=radio]:checked", this.element).each(
             function(index, sel) {
                 optionsSelected[sel.name] = sel.value;
             }
@@ -211,17 +222,46 @@ OpenAssessment.BaseUI.prototype = {
 
         // Send the assessment to the server
         var ui = this;
-        this.server.assess(submissionId, optionsSelected, feedback).done(
+        this.server.peerAssess(submissionId, optionsSelected, feedback).done(
             function() {
-                // When we have successfully sent the assessment, expand the next step
-                ui.renderPeerAssessmentStep(true);
+                // When we have successfully sent the assessment,
+                // collapse the current step and expand the next step
+                ui.renderPeerAssessmentStep(false);
                 ui.renderSelfAssessmentStep(true);
-                ui.renderGradeStep(true);
+                ui.renderGradeStep(false);
             }
         ).fail(function(errMsg) {
             // TODO: display to the user
             console.log(errMsg);
         });
+    },
+
+    /**
+    Send a self-assessment to the server and update the UI.
+    **/
+    selfAssess: function() {
+        // Retrieve self-assessment info from the DOM
+        var submissionId = $("span#self_submission_uuid", this.element)[0].innerText;
+        var optionsSelected = {};
+        $("#self-assessment--001__assessment input[type=radio]:checked", this.element).each(
+            function(index, sel) {
+                optionsSelected[sel.name] = sel.value;
+            }
+        );
+
+        // Send the assessment to the server
+        var ui = this;
+        this.server.selfAssess(submissionId, optionsSelected).done(
+            function() {
+                // When we have successfully sent the assessment,
+                // collapse the current step and expand the next step
+                ui.renderSelfAssessmentStep(false);
+                ui.renderGradeStep(true);
+            }
+        ).fail(function(errMsg) {
+            // TODO: display to user
+            console.log(errMsg);
+        });
     }
 };
 

apps/openassessment/xblock/static/js/src/oa_server.js

@@ -131,7 +131,7 @@ OpenAssessment.Server.prototype = {
     },
 
     /**
-    Send an assessment to the XBlock.
+    Send a peer assessment to the XBlock.
 
     Args:
         submissionId (string): The UUID of the submission.
@@ -146,14 +146,14 @@ OpenAssessment.Server.prototype = {
     Example:
         var options = { clarity: "Very clear", precision: "Somewhat precise" };
         var feedback = "Good job!";
-        server.assess("abc123", options, feedback).done(
+        server.peerAssess("abc123", options, feedback).done(
             function() { console.log("Success!"); }
         ).fail(
             function(errorMsg) { console.log(errorMsg); }
         );
     **/
-    assess: function(submissionId, optionsSelected, feedback) {
-        var url = this.url('assess');
+    peerAssess: function(submissionId, optionsSelected, feedback) {
+        var url = this.url('peer_assess');
         var payload = JSON.stringify({
             submission_uuid: submissionId,
             options_selected: optionsSelected,
@@ -176,6 +176,48 @@ OpenAssessment.Server.prototype = {
     },
 
     /**
+    Send a self-assessment to the XBlock.
+
+    Args:
+        submissionId (string): The UUID of the submission.
+        optionsSelected (object literal): Keys are criteria names,
+            values are the option text the user selected for the criterion.
+
+    Returns:
+        A JQuery promise, which resolves with no args if successful
+        and fails with an error message otherwise.
+
+    Example:
+        var options = { clarity: "Very clear", precision: "Somewhat precise" };
+        server.selfAssess("abc123", options).done(
+            function() { console.log("Success!"); }
+        ).fail(
+            function(errorMsg) { console.log(errorMsg); }
+        );
+    **/
+    selfAssess: function(submissionId, optionsSelected) {
+        var url = this.url('self_assess');
+        var payload = JSON.stringify({
+            submission_uuid: submissionId,
+            options_selected: optionsSelected
+        });
+        return $.Deferred(function(defer) {
+            $.ajax({ type: "POST", url: url, data: payload }).done(
+                function(data) {
+                    if (data.success) {
+                        defer.resolve();
+                    }
+                    else {
+                        defer.rejectWith(this, [data.msg]);
+                    }
+                }
+            ).fail(function(data) {
+                defer.rejectWith(this, ['Could not contact server.']);
+            });
+        });
+    },
+
+    /**
     Load the XBlock's XML definition from the server.
 
     Returns:

apps/openassessment/xblock/static/xml/poverty_rubric_example.xml

@@ -110,9 +110,6 @@
                     due="2014-12-21T22:22-7:00"
                     must_grade="5"
                     must_be_graded_by="3" />
-        <assessment name="self-assessment"
-                    due="2014-12-21T22:22-7:00"
-                    must_grade="5"
-                    must_be_graded_by="3" />
+        <assessment name="self-assessment" due="2014-12-21T22:22-7:00" />
     </assessments>
 </openassessment>

apps/openassessment/xblock/studio_mixin.py

@@ -13,7 +13,7 @@ from openassessment.xblock.xml import (
     UpdateFromXmlError, InvalidRubricError
 )
 
-from openassessment.peer.serializers import validate_assessment_dict, validate_rubric_dict
+from openassessment.assessment.serializers import validate_assessment_dict, validate_rubric_dict
 
 
 logger = logging.getLogger(__name__)

apps/openassessment/xblock/submission_mixin.py

 from xblock.core import XBlock
-from submissions import api
 from django.utils.translation import ugettext as _
-from openassessment.peer import api as peer_api
+from submissions import api
+from openassessment.assessment import peer_api
 from openassessment.workflow import api as workflow_api
 
 

apps/openassessment/xblock/test/data/assessment_scenario.xml → apps/openassessment/xblock/test/data/peer_assessment_scenario.xml

@@ -40,10 +40,6 @@
         </criterion>
     </rubric>
     <assessments>
-        <assessment name="peer-assessment"
-          start="2014-12-20T19:00"
-          due="2014-12-21T22:22"
-          must_grade="5"
-          must_be_graded_by="3" />
+        <assessment name="peer-assessment" must_grade="5" must_be_graded_by="3" />
     </assessments>
 </openassessment>

apps/openassessment/xblock/test/data/self_assessment_scenario.xml

+<openassessment>
+    <title>Open Assessment Test</title>
+    <prompt>
+        Given the state of the world today, what do you think should be done to
+        combat poverty? Please answer in a short essay of 200-300 words.
+    </prompt>
+    <rubric>
+        <prompt>Read for conciseness, clarity of thought, and form.</prompt>
+        <criterion>
+            <name>𝓒𝓸𝓷𝓬𝓲𝓼𝓮</name>
+            <prompt>How concise is it?</prompt>
+            <option points="3">
+                <name>ﻉซƈﻉɭɭﻉกՇ</name>
+                <explanation>Extremely concise</explanation>
+            </option>
+            <option points="2">
+                <name>Ġööḋ</name>
+                <explanation>Concise</explanation>
+            </option>
+            <option points="1">
+                <name>ק๏๏г</name>
+                <explanation>Wordy</explanation>
+            </option>
+        </criterion>
+        <criterion>
+            <name>Form</name>
+            <prompt>How well-formed is it?</prompt>
+            <option points="3">
+                <name>Good</name>
+                <explanation>Good</explanation>
+            </option>
+            <option points="2">
+                <name>Fair</name>
+                <explanation>Fair</explanation>
+            </option>
+            <option points="1">
+                <name>Poor</name>
+                <explanation>Poor</explanation>
+            </option>
+        </criterion>
+    </rubric>
+    <assessments>
+        <assessment name="self-assessment" />
+    </assessments>
+</openassessment>

apps/openassessment/xblock/test/data/update_from_xml_error.json

@@ -278,45 +278,5 @@
             "</rubric>",
             "</openassessment>"
         ]
-    },
-
-    "missing_must_grade": {
-        "xml": [
-            "<openassessment>",
-            "<title>Foo</title>",
-            "<assessments>",
-                "<assessment name=\"peer-assessment\" start=\"2014-02-27T09:46:28\" due=\"2014-03-01T00:00:00\" must_be_graded_by=\"3\" />",
-            "</assessments>",
-            "<rubric>",
-                "<prompt>Test prompt</prompt>",
-                "<criterion>",
-                    "<name>Test criterion</name>",
-                    "<prompt>Test criterion prompt</prompt>",
-                    "<option points=\"0\"><name>No</name><explanation>No explanation</explanation></option>",
-                    "<option points=\"2\"><name>Yes</name><explanation>Yes explanation</explanation></option>",
-                "</criterion>",
-            "</rubric>",
-            "</openassessment>"
-        ]
-    },
-
-    "missing_must_be_graded_by": {
-        "xml": [
-            "<openassessment>",
-            "<title>Foo</title>",
-            "<assessments>",
-                "<assessment name=\"peer-assessment\" start=\"2014-02-27T09:46:28\" due=\"2014-03-01T00:00:00\" must_grade=\"5\"  />",
-            "</assessments>",
-            "<rubric>",
-                "<prompt>Test prompt</prompt>",
-                "<criterion>",
-                    "<name>Test criterion</name>",
-                    "<prompt>Test criterion prompt</prompt>",
-                    "<option points=\"0\"><name>No</name><explanation>No explanation</explanation></option>",
-                    "<option points=\"2\"><name>Yes</name><explanation>Yes explanation</explanation></option>",
-                "</criterion>",
-            "</rubric>",
-            "</openassessment>"
-        ]
     }
 }

apps/openassessment/xblock/test/data/updated_block.xml

@@ -2,7 +2,7 @@
 <title>Foo</title>
 <assessments>
     <assessment name="peer-assessment" start="2014-02-27T09:46:28" due="2014-03-01T00:00:00" must_grade="5" must_be_graded_by="3" />
-    <assessment name="self-assessment" start="2014-04-01T00:00:00" due="2014-06-01T00:00:00" must_grade="2" must_be_graded_by="1" />
+    <assessment name="self-assessment" start="2014-04-01T00:00:00" due="2014-06-01T00:00:00" />
 </assessments>
 <rubric>
     <prompt>Test prompt</prompt>

apps/openassessment/xblock/test/test_grade.py

@@ -4,7 +4,7 @@ Tests for grade handlers in Open Assessment XBlock.
 """
 import copy
 import json
-from openassessment.peer import api as peer_api
+from openassessment.assessment import peer_api
 from submissions import api as sub_api
 from .base import XBlockHandlerTestCase, scenario
 

apps/openassessment/xblock/test/test_peer.py

@@ -5,7 +5,8 @@ Tests for peer assessment handlers in Open Assessment XBlock.
 
 import copy
 import json
-from openassessment.peer import api as peer_api
+from openassessment.assessment import peer_api
+from submissions import api as submission_api
 from .base import XBlockHandlerTestCase, scenario
 
 
@@ -19,7 +20,7 @@ class TestPeerAssessment(XBlockHandlerTestCase):
 
     SUBMISSION = u'ՇﻉรՇ รપ๒๓ٱรรٱѻก'
 
-    @scenario('data/assessment_scenario.xml', user_id='Bob')
+    @scenario('data/peer_assessment_scenario.xml', user_id='Bob')
     def test_assess_handler(self, xblock):
 
         # Create a submission for this problem from another user
@@ -35,7 +36,7 @@ class TestPeerAssessment(XBlockHandlerTestCase):
         # Submit an assessment and expect a successful response
         assessment = copy.deepcopy(self.ASSESSMENT)
         assessment['submission_uuid'] = submission['uuid']
-        resp = self.request(xblock, 'assess', json.dumps(assessment), response_format='json')
+        resp = self.request(xblock, 'peer_assess', json.dumps(assessment), response_format='json')
         self.assertTrue(resp['success'])
 
         # Retrieve the assessment and check that it matches what we sent
@@ -56,7 +57,7 @@ class TestPeerAssessment(XBlockHandlerTestCase):
 
         self.assertEqual(actual[0]['feedback'], assessment['feedback'])
 
-    @scenario('data/assessment_scenario.xml', user_id='Bob')
+    @scenario('data/peer_assessment_scenario.xml', user_id='Bob')
     def test_assess_rubric_option_mismatch(self, xblock):
 
         # Create a submission for this problem from another user
@@ -73,16 +74,16 @@ class TestPeerAssessment(XBlockHandlerTestCase):
         assessment = copy.deepcopy(self.ASSESSMENT)
         assessment['submission_uuid'] = submission['uuid']
         assessment['options_selected']['invalid'] = 'not a part of the rubric!'
-        resp = self.request(xblock, 'assess', json.dumps(assessment), response_format='json')
+        resp = self.request(xblock, 'peer_assess', json.dumps(assessment), response_format='json')
 
         # Expect an error response
         self.assertFalse(resp['success'])
 
 
-    @scenario('data/assessment_scenario.xml', user_id='Bob')
+    @scenario('data/peer_assessment_scenario.xml', user_id='Bob')
     def test_missing_keys_in_request(self, xblock):
         for missing in ['feedback', 'submission_uuid', 'options_selected']:
             assessment = copy.deepcopy(self.ASSESSMENT)
             del assessment[missing]
-            resp = self.request(xblock, 'assess', json.dumps(assessment), response_format='json')
+            resp = self.request(xblock, 'peer_assess', json.dumps(assessment), response_format='json')
             self.assertEqual(resp['success'], False)

apps/openassessment/xblock/test/test_self.py

+# -*- coding: utf-8 -*-
+"""
+Tests for self assessment handlers in Open Assessment XBlock.
+"""
+import copy
+import json
+import mock
+from submissions import api as submission_api
+from openassessment.assessment import self_api
+from .base import XBlockHandlerTestCase, scenario
+
+
+class TestSelfAssessment(XBlockHandlerTestCase):
+
+    maxDiff = None
+
+    SUBMISSION = u'ՇﻉรՇ รપ๒๓ٱรรٱѻก'
+
+    ASSESSMENT = {
+        'submission_uuid': None,
+        'options_selected': {u'𝓒𝓸𝓷𝓬𝓲𝓼𝓮': u'ﻉซƈﻉɭɭﻉกՇ', u'Form': u'Fair'},
+    }
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_self_assess_handler(self, xblock):
+        student_item = xblock.get_student_item_dict()
+
+        # Create a submission for the student
+        submission = submission_api.create_submission(student_item, self.SUBMISSION)
+
+        # Submit a self-assessment
+        assessment = copy.deepcopy(self.ASSESSMENT)
+        assessment['submission_uuid'] = submission['uuid']
+        resp = self.request(xblock, 'self_assess', json.dumps(assessment), response_format='json')
+        self.assertTrue(resp['success'])
+
+        # Expect that a self-assessment was created
+        _, assessment = self_api.get_submission_and_assessment(student_item)
+        self.assertEqual(assessment['submission_uuid'], submission['uuid'])
+        self.assertEqual(assessment['points_earned'], 5)
+        self.assertEqual(assessment['points_possible'], 6)
+        self.assertEqual(assessment['scorer_id'], 'Bob')
+        self.assertEqual(assessment['score_type'], 'SE')
+        self.assertEqual(assessment['feedback'], u'')
+
+        parts = sorted(assessment['parts'])
+        self.assertEqual(len(parts), 2)
+        self.assertEqual(parts[0]['option']['criterion']['name'], u'Form')
+        self.assertEqual(parts[0]['option']['name'], 'Fair')
+        self.assertEqual(parts[1]['option']['criterion']['name'], u'𝓒𝓸𝓷𝓬𝓲𝓼𝓮')
+        self.assertEqual(parts[1]['option']['name'], u'ﻉซƈﻉɭɭﻉกՇ')
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_self_assess_handler_missing_keys(self, xblock):
+        # Missing submission_uuid
+        assessment = copy.deepcopy(self.ASSESSMENT)
+        del assessment['submission_uuid']
+        resp = self.request(xblock, 'self_assess', json.dumps(assessment), response_format='json')
+        self.assertFalse(resp['success'])
+        self.assertIn('submission_uuid', resp['msg'])
+
+        # Missing options_selected
+        assessment = copy.deepcopy(self.ASSESSMENT)
+        del assessment['options_selected']
+        resp = self.request(xblock, 'self_assess', json.dumps(assessment), response_format='json')
+        self.assertFalse(resp['success'])
+        self.assertIn('options_selected', resp['msg'])
+
+    # No user specified, to simulate the Studio preview runtime
+    @scenario('data/self_assessment_scenario.xml')
+    def test_render_self_assessment_preview(self, xblock):
+        resp = self.request(xblock, 'render_self_assessment', json.dumps(dict()))
+        self.assertIn("Incomplete", resp)
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_render_self_assessment_complete(self, xblock):
+        student_item = xblock.get_student_item_dict()
+
+        # Create a submission for the student
+        submission = submission_api.create_submission(student_item, self.SUBMISSION)
+
+        # Self-assess the submission
+        assessment = copy.deepcopy(self.ASSESSMENT)
+        assessment['submission_uuid'] = submission['uuid']
+        resp = self.request(xblock, 'self_assess', json.dumps(assessment), response_format='json')
+        self.assertTrue(resp['success'])
+
+        # Expect that the self assessment shows that we've completed the step
+        resp = self.request(xblock, 'render_self_assessment', json.dumps(dict()))
+        self.assertIn("Complete", resp)
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_render_self_assessment_open(self, xblock):
+        student_item = xblock.get_student_item_dict()
+
+        # Create a submission for the student
+        submission = submission_api.create_submission(student_item, self.SUBMISSION)
+
+        # Expect that the self-assessment step is open
+        resp = self.request(xblock, 'render_self_assessment', json.dumps(dict()))
+        self.assertIn("Grading", resp)
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_render_self_assessment_no_submission(self, xblock):
+        # Without creating a submission, render the self-assessment step
+        # Expect that the step is closed
+        resp = self.request(xblock, 'render_self_assessment', json.dumps(dict()))
+        self.assertIn("Incomplete", resp)
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_render_self_assessessment_api_error(self, xblock):
+        # Create a submission for the student
+        student_item = xblock.get_student_item_dict()
+        submission = submission_api.create_submission(student_item, self.SUBMISSION)
+
+        # Simulate an error and expect a failure response
+        with mock.patch('openassessment.xblock.self_assessment_mixin.self_api') as mock_api:
+            mock_api.SelfAssessmentRequestError = self_api.SelfAssessmentRequestError
+            mock_api.get_submission_and_assessment.side_effect = self_api.SelfAssessmentRequestError
+            resp = self.request(xblock, 'render_self_assessment', json.dumps(dict()))
+        self.assertIn("error", resp.lower())
+
+    @scenario('data/self_assessment_scenario.xml', user_id='Bob')
+    def test_self_assess_api_error(self, xblock):
+        # Create a submission for the student
+        student_item = xblock.get_student_item_dict()
+        submission = submission_api.create_submission(student_item, self.SUBMISSION)
+
+        # Submit a self-assessment
+        assessment = copy.deepcopy(self.ASSESSMENT)
+        assessment['submission_uuid'] = submission['uuid']
+
+        # Simulate an error and expect a failure response
+        with mock.patch('openassessment.xblock.self_assessment_mixin.self_api') as mock_api:
+            mock_api.SelfAssessmentRequestError = self_api.SelfAssessmentRequestError
+            mock_api.create_assessment.side_effect = self_api.SelfAssessmentRequestError
+            resp = self.request(xblock, 'self_assess', json.dumps(assessment), response_format='json')
+
+        self.assertFalse(resp['success'])

apps/openassessment/xblock/xml.py

@@ -365,8 +365,6 @@ def _parse_assessments_xml(assessments_root, validator):
                 assessment_dict['must_grade'] = int(assessment.get('must_grade'))
             except ValueError:
                 raise UpdateFromXmlError(_('Assessment "must_grade" attribute must be an integer.'))
-        else:
-            raise UpdateFromXmlError(_('XML assessment definition must have a "must_grade" attribute'))
 
         # Assessment must_be_graded_by
         if 'must_be_graded_by' in assessment.attrib:
@@ -374,8 +372,6 @@ def _parse_assessments_xml(assessments_root, validator):
                 assessment_dict['must_be_graded_by'] = int(assessment.get('must_be_graded_by'))
             except ValueError:
                 raise UpdateFromXmlError(_('Assessment "must_be_graded_by" attribute must be an integer.'))
-        else:
-            raise UpdateFromXmlError(_('XML assessment definition must have a "must_be_graded_by" attribute'))
 
         # Validate the semantics of the assessment definition
         success, msg = validator(assessment_dict)

apps/submissions/api.py

@@ -192,6 +192,29 @@ def get_submission(submission_uuid):
 
     return SubmissionSerializer(submission).data
 
+def get_submission_by_uuid(uuid):
+    """
+    Retrieve a submission by its unique identifier.
+
+    Args:
+        uuid (str): the unique identifier of the submission.
+
+    Returns:
+        Serialized Submission model (dict) containing a serialized StudentItem model
+        If the submission does not exist, return None
+    """
+    try:
+        submission = Submission.objects.get(uuid=uuid)
+    except Submission.DoesNotExist:
+        return None
+
+    # There is probably a more idiomatic way to do this using the Django REST framework
+    submission_dict = SubmissionSerializer(submission).data
+    submission_dict['student_item'] = StudentItemSerializer(submission.student_item).data
+
+    return submission_dict
+
+
 def get_submissions(student_item_dict, limit=None):
     """Retrieves the submissions for the specified student item,
     ordered by most recent submitted date.

apps/submissions/serializers.py

@@ -13,6 +13,7 @@ class StudentItemSerializer(serializers.ModelSerializer):
 
 
 class SubmissionSerializer(serializers.ModelSerializer):
+
     class Meta:
         model = Submission
         fields = (
@@ -21,7 +22,7 @@ class SubmissionSerializer(serializers.ModelSerializer):
             'attempt_number',
             'submitted_at',
             'created_at',
-            'answer'
+            'answer',
         )
 
 

apps/submissions/tests/test_api.py

@@ -41,6 +41,17 @@ class TestSubmissionsApi(TestCase):
         submission = api.create_submission(STUDENT_ITEM, ANSWER_ONE)
         self._assert_submission(submission, ANSWER_ONE, 1, 1)
 
+    def test_get_submission_by_uuid(self):
+        submission = api.create_submission(STUDENT_ITEM, ANSWER_ONE)
+
+        # Retrieve the submission by its uuid
+        retrieved = api.get_submission_by_uuid(submission['uuid'])
+        self.assertItemsEqual(submission, retrieved)
+
+        # Should get None if we retrieve a submission that doesn't exist
+        retrieved = api.get_submission_by_uuid(u'no such uuid')
+        self.assertIs(retrieved, None)
+
     def test_get_submissions(self):
         api.create_submission(STUDENT_ITEM, ANSWER_ONE)
         api.create_submission(STUDENT_ITEM, ANSWER_TWO)

settings/base.py

@@ -140,8 +140,8 @@ INSTALLED_APPS = (
     # edx-tim apps
     'submissions',
     'openassessment',
-    'openassessment.peer',
     'openassessment.workflow',
+    'openassessment.assessment',
 )
 
 # A sample logging configuration. The only tangible logging

settings/test.py

@@ -6,7 +6,7 @@ Test-specific Django settings.
 from .base import *
 
 TEST_APPS = (
-    'openassessment.peer',
+    'openassessment.assessment',
     'openassessment.workflow',
     'openassessment.xblock',
     'submissions',

setup.py

@@ -4,7 +4,7 @@ from setuptools import setup
 
 PACKAGES = [
     'submissions',
-    'openassessment.peer',
+    'openassessment.assessment',
     'openassessment.xblock'
 ]
 

urls.py

 from django.conf.urls import include, patterns, url
 from django.contrib import admin
 
-import openassessment.peer.urls
+import openassessment.assessment.urls
 import submissions.urls
 import workbench.urls
 
@@ -19,5 +19,5 @@ urlpatterns = patterns(
     url(r'^submissions/', include(submissions.urls)),
 
     # edx-tim apps
-    url(r'^peer/evaluations/', include(openassessment.peer.urls)),
+    url(r'^peer/evaluations/', include(openassessment.assessment.urls)),
 )