Added tests for exception handling using the mock library.

apps/submissions/api.py

@@ -67,10 +67,10 @@ def create_submission(student_item_dict, answer, submitted_at=None,
         try:
             submissions = Submission.objects.filter(
                 student_item=student_item_model)[:0]
-        except DatabaseError as err:
-            error_message = u"An unexpected error occurred while filtering "
-            u"submissions for a create submission request: {}".format(err)
-            logger.error(error_message)
+        except DatabaseError:
+            error_message = u"An error occurred while filtering "
+            u"submissions for student item: {}".format(student_item_dict)
+            logger.exception(error_message)
             raise SubmissionInternalError(error_message)
         attempt_number = submissions[0].attempt_number + 1 if submissions else 1
 
@@ -84,10 +84,13 @@ def create_submission(student_item_dict, answer, submitted_at=None,
 
     try:
         submission = Submission.objects.create(**model_kwargs)
-    except DatabaseError as err:
-        error_message = u"An unexpected error occurred while creating a "
-        u"submission for a create submission request: {}".format(err)
-        logger.error(error_message)
+    except DatabaseError:
+        error_message = u"An error occurred while creating "
+        u"submission {} for student item: {}".format(
+            model_kwargs,
+            student_item_dict
+        )
+        logger.exception(error_message)
         raise SubmissionInternalError(error_message)
 
     return SubmissionSerializer(submission).data
@@ -122,10 +125,10 @@ def get_submissions(student_item_dict, limit=None):
     try:
         submission_models = Submission.objects.filter(
             student_item=student_item_model)
-    except DatabaseError as err:
-        error_message = u"An unexpected error occurred while filtering "
-        u"submissions for a get submissions request: {}".format(err)
-        logger.error(error_message)
+    except DatabaseError:
+        error_message = u"Error getting submission request for student item {}".format(
+            student_item_dict)
+        logger.exception(error_message)
         raise SubmissionNotFoundError(error_message)
 
     if limit:
@@ -149,6 +152,7 @@ def set_score(student_item):
 
 def _get_or_create_student_item(student_item_dict):
     try:
+        try:
             student_item_model = StudentItem.objects.get(**student_item_dict)
         except StudentItem.DoesNotExist:
             student_item_serializer = StudentItemSerializer(data=student_item_dict)
@@ -157,8 +161,8 @@ def _get_or_create_student_item(student_item_dict):
                 raise SubmissionRequestError(student_item_serializer.errors)
             student_item_model = StudentItem.objects.create(**student_item_dict)
     except DatabaseError:
-        error_message = u"An error occurred creating a student item for: {!r}".format(
+        error_message = u"An error occurred creating student item: {}".format(
             student_item_dict)
-        logger.error(error_message)
+        logger.exception(error_message)
         raise SubmissionInternalError(error_message)
     return student_item_model

apps/submissions/tests/test_api.py

 import datetime
+from django.db import DatabaseError
 
 from django.test import TestCase
-import sys
+from nose.tools import raises
+from mock import patch
 
-from submissions.api import create_submission, get_submissions, SubmissionRequestError
+from submissions.api import create_submission, get_submissions, SubmissionRequestError, SubmissionInternalError
+from submissions.models import Submission, StudentItem
 
 STUDENT_ITEM = dict(
     student_id="Tim",
@@ -23,7 +26,6 @@ ANSWER_TWO = u"this is my other answer!"
 
 
 class TestApi(TestCase):
-
     def test_create_submission(self):
         submission = create_submission(STUDENT_ITEM, ANSWER_ONE)
         self._assert_submission(submission, ANSWER_ONE, 1, 1)
@@ -46,19 +48,30 @@ class TestApi(TestCase):
         submissions = get_submissions(STUDENT_ITEM, 1)
         self.assertEqual(1, len(submissions))
         self.assertEqual(ANSWER_ONE, submissions[0]["answer"])
-        self.assertEqual(more_recent_date.year, submissions[0]["submitted_at"].year)
+        self.assertEqual(more_recent_date.year,
+                         submissions[0]["submitted_at"].year)
 
     def test_set_attempt_number(self):
         create_submission(STUDENT_ITEM, ANSWER_ONE, None, 2)
         submissions = get_submissions(STUDENT_ITEM)
         self._assert_submission(submissions[0], ANSWER_ONE, 1, 2)
 
+    @raises(SubmissionRequestError)
     def test_error_checking(self):
-        try:
         create_submission(BAD_STUDENT_ITEM, -100)
-            self.fail("Bad Student Item should fail validation")
-        except SubmissionRequestError as err:
-            self.assertEqual([u"This field is required."], err.field_errors["item_type"])
+
+    @patch.object(Submission.objects, 'filter')
+    @raises(SubmissionInternalError)
+    def test_error_on_submission_creation(self, mock_filter):
+        mock_filter.side_effect = DatabaseError("Bad things happened")
+        create_submission(STUDENT_ITEM, ANSWER_ONE)
+
+    @patch.object(StudentItem.objects, 'create')
+    @raises(SubmissionInternalError)
+    def test_error_on_create_student_item(self, mock_create):
+        mock_create.side_effect = DatabaseError("Bad things happened")
+        create_submission(STUDENT_ITEM, ANSWER_ONE)
+
 
     def _assert_submission(self, submission, expected_answer, expected_item,
                            expected_attempt):