Merge pull request #1602 from MITx/fix/will/capa_xmodule_unit_tests

Fix/will/capa xmodule unit tests

common/lib/xmodule/xmodule/tests/__init__.py

@@ -28,21 +28,35 @@ open_ended_grading_interface = {
         'grading_controller' : 'grading_controller'
     }
 
-test_system = ModuleSystem(
-    ajax_url='courses/course_id/modx/a_location',
-    track_function=Mock(),
-    get_module=Mock(),
-    # "render" to just the context...
-    render_template=lambda template, context: str(context),
-    replace_urls=Mock(),
-    user=Mock(is_staff=False),
-    filestore=Mock(),
-    debug=True,
-    xqueue={'interface': None, 'callback_url': '/', 'default_queuename': 'testqueue', 'waittime': 10},
-    node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
-    anonymous_student_id='student',
-    open_ended_grading_interface= open_ended_grading_interface
-)
+
+def test_system():
+    """
+    Construct a test ModuleSystem instance.
+
+    By default, the render_template() method simply returns
+    the context it is passed as a string.
+    You can override this behavior by monkey patching:
+
+    system = test_system()
+    system.render_template = my_render_func
+
+    where my_render_func is a function of the form
+    my_render_func(template, context)
+    """
+    return ModuleSystem(
+        ajax_url='courses/course_id/modx/a_location',
+        track_function=Mock(),
+        get_module=Mock(),
+        render_template=lambda template, context: str(context),
+        replace_urls=lambda html: str(html),
+        user=Mock(is_staff=False),
+        filestore=Mock(),
+        debug=True,
+        xqueue={'interface': None, 'callback_url': '/', 'default_queuename': 'testqueue', 'waittime': 10},
+        node_path=os.environ.get("NODE_PATH", "/usr/local/lib/node_modules"),
+        anonymous_student_id='student',
+        open_ended_grading_interface= open_ended_grading_interface
+    )
 
 
 class ModelsTest(unittest.TestCase):

common/lib/xmodule/xmodule/tests/test_combined_open_ended.py

@@ -54,7 +54,8 @@ class OpenEndedChildTest(unittest.TestCase):
     descriptor = Mock()
 
     def setUp(self):
-        self.openendedchild = OpenEndedChild(test_system, self.location,
+        self.test_system = test_system()
+        self.openendedchild = OpenEndedChild(self.test_system, self.location,
                 self.definition, self.descriptor, self.static_data, self.metadata) 
 
 
@@ -69,7 +70,7 @@ class OpenEndedChildTest(unittest.TestCase):
 
 
     def test_latest_post_assessment_empty(self):
-        answer = self.openendedchild.latest_post_assessment(test_system)
+        answer = self.openendedchild.latest_post_assessment(self.test_system)
         self.assertEqual(answer, "")
 
 
@@ -106,7 +107,7 @@ class OpenEndedChildTest(unittest.TestCase):
         post_assessment = "Post assessment"
         self.openendedchild.record_latest_post_assessment(post_assessment)
         self.assertEqual(post_assessment,
-                self.openendedchild.latest_post_assessment(test_system))
+                self.openendedchild.latest_post_assessment(self.test_system))
 
     def test_get_score(self):
         new_answer = "New Answer"
@@ -125,7 +126,7 @@ class OpenEndedChildTest(unittest.TestCase):
 
 
     def test_reset(self):
-        self.openendedchild.reset(test_system)
+        self.openendedchild.reset(self.test_system)
         state = json.loads(self.openendedchild.get_instance_state())
         self.assertEqual(state['state'], OpenEndedChild.INITIAL)
 
@@ -182,11 +183,13 @@ class OpenEndedModuleTest(unittest.TestCase):
     descriptor = Mock()
 
     def setUp(self):
-        test_system.location = self.location
+        self.test_system = test_system()
+
+        self.test_system.location = self.location
         self.mock_xqueue = MagicMock()
         self.mock_xqueue.send_to_queue.return_value = (None, "Message")
-        test_system.xqueue = {'interface': self.mock_xqueue, 'callback_url': '/', 'default_queuename': 'testqueue', 'waittime': 1}
-        self.openendedmodule = OpenEndedModule(test_system, self.location,
+        self.test_system.xqueue = {'interface': self.mock_xqueue, 'callback_url': '/', 'default_queuename': 'testqueue', 'waittime': 1}
+        self.openendedmodule = OpenEndedModule(self.test_system, self.location,
                 self.definition, self.descriptor, self.static_data, self.metadata) 
 
     def test_message_post(self):
@@ -195,7 +198,7 @@ class OpenEndedModuleTest(unittest.TestCase):
                 'grader_id': '1',
                 'score': 3}
         qtime = datetime.strftime(datetime.now(), xqueue_interface.dateformat)
-        student_info = {'anonymous_student_id': test_system.anonymous_student_id,
+        student_info = {'anonymous_student_id': self.test_system.anonymous_student_id,
                 'submission_time': qtime}
         contents = {
                 'feedback': get['feedback'],
@@ -205,7 +208,7 @@ class OpenEndedModuleTest(unittest.TestCase):
                 'student_info': json.dumps(student_info)
                 }
 
-        result = self.openendedmodule.message_post(get, test_system)
+        result = self.openendedmodule.message_post(get, self.test_system)
         self.assertTrue(result['success'])
         # make sure it's actually sending something we want to the queue
         self.mock_xqueue.send_to_queue.assert_called_with(body=json.dumps(contents), header=ANY)
@@ -216,7 +219,7 @@ class OpenEndedModuleTest(unittest.TestCase):
     def test_send_to_grader(self):
         submission = "This is a student submission"
         qtime = datetime.strftime(datetime.now(), xqueue_interface.dateformat)
-        student_info = {'anonymous_student_id': test_system.anonymous_student_id,
+        student_info = {'anonymous_student_id': self.test_system.anonymous_student_id,
                 'submission_time': qtime}
         contents = self.openendedmodule.payload.copy()
         contents.update({
@@ -224,7 +227,7 @@ class OpenEndedModuleTest(unittest.TestCase):
             'student_response': submission,
             'max_score': self.max_score
             })
-        result = self.openendedmodule.send_to_grader(submission, test_system)
+        result = self.openendedmodule.send_to_grader(submission, self.test_system)
         self.assertTrue(result)
         self.mock_xqueue.send_to_queue.assert_called_with(body=json.dumps(contents), header=ANY)
 
@@ -238,7 +241,7 @@ class OpenEndedModuleTest(unittest.TestCase):
                 }
         get = {'queuekey': "abcd",
                 'xqueue_body': score_msg}
-        self.openendedmodule.update_score(get, test_system)
+        self.openendedmodule.update_score(get, self.test_system)
 
     def update_score_single(self):
         self.openendedmodule.new_history_entry("New Entry")
@@ -261,11 +264,11 @@ class OpenEndedModuleTest(unittest.TestCase):
                 }
         get = {'queuekey': "abcd",
                 'xqueue_body': json.dumps(score_msg)}
-        self.openendedmodule.update_score(get, test_system)
+        self.openendedmodule.update_score(get, self.test_system)
 
     def test_latest_post_assessment(self):
         self.update_score_single()
-        assessment = self.openendedmodule.latest_post_assessment(test_system)
+        assessment = self.openendedmodule.latest_post_assessment(self.test_system)
         self.assertFalse(assessment == '')
         # check for errors
         self.assertFalse('errors' in assessment)
@@ -336,7 +339,13 @@ class CombinedOpenEndedModuleTest(unittest.TestCase):
     descriptor = Mock()
 
     def setUp(self):
-        self.combinedoe = CombinedOpenEndedV1Module(test_system, self.location, self.definition, self.descriptor, static_data = self.static_data, metadata=self.metadata)
+        self.test_system = test_system()
+        self.combinedoe = CombinedOpenEndedV1Module(self.test_system, 
+                                                self.location, 
+                                                self.definition, 
+                                                self.descriptor, 
+                                                static_data = self.static_data, 
+                                                metadata=self.metadata)
 
     def test_get_tag_name(self):
         name = self.combinedoe.get_tag_name("<t>Tag</t>")

common/lib/xmodule/xmodule/tests/test_conditional.py

@@ -56,6 +56,9 @@ class ConditionalModuleTest(unittest.TestCase):
         '''Get a dummy system'''
         return DummySystem(load_error_modules)
 
+    def setUp(self):
+        self.test_system = test_system()
+
     def get_course(self, name):
         """Get a test course by directory name.  If there's more than one, error."""
         print "Importing {0}".format(name)
@@ -85,14 +88,14 @@ class ConditionalModuleTest(unittest.TestCase):
             location = descriptor.location
             instance_state = instance_states.get(location.category, None)
             print "inner_get_module, location=%s, inst_state=%s" % (location, instance_state)
-            return descriptor.xmodule_constructor(test_system)(instance_state, shared_state)
+            return descriptor.xmodule_constructor(self.test_system)(instance_state, shared_state)
 
         location = Location(["i4x", "edX", "cond_test", "conditional", "condone"])
 
         def replace_urls(text, staticfiles_prefix=None, replace_prefix='/static/', course_namespace=None):
             return text
-        test_system.replace_urls = replace_urls
-        test_system.get_module = inner_get_module
+        self.test_system.replace_urls = replace_urls
+        self.test_system.get_module = inner_get_module
 
         module = inner_get_module(location)
         print "module: ", module

common/lib/xmodule/xmodule/tests/test_self_assessment.py

@@ -53,13 +53,13 @@ class SelfAssessmentTest(unittest.TestCase):
                 'skip_basic_checks' : False,
                 }
 
-        self.module = SelfAssessmentModule(test_system, self.location,
+        self.module = SelfAssessmentModule(test_system(), self.location,
                                       self.definition, self.descriptor,
                                       static_data, 
                                       state, metadata=self.metadata)
 
     def test_get_html(self):
-        html = self.module.get_html(test_system)
+        html = self.module.get_html(self.module.system)
         self.assertTrue("This is sample prompt text" in html)
 
     def test_self_assessment_flow(self):
@@ -82,10 +82,11 @@ class SelfAssessmentTest(unittest.TestCase):
 
         self.assertEqual(self.module.get_score()['score'], 0)
 
-        self.module.save_answer({'student_answer': "I am an answer"}, test_system)
+        self.module.save_answer({'student_answer': "I am an answer"}, 
+                                self.module.system)
         self.assertEqual(self.module.state, self.module.ASSESSING)
 
-        self.module.save_assessment(mock_query_dict, test_system)
+        self.module.save_assessment(mock_query_dict, self.module.system)
         self.assertEqual(self.module.state, self.module.DONE)
 
 
@@ -94,7 +95,8 @@ class SelfAssessmentTest(unittest.TestCase):
         self.assertEqual(self.module.state, self.module.INITIAL)
 
         # if we now assess as right, skip the REQUEST_HINT state
-        self.module.save_answer({'student_answer': 'answer 4'}, test_system)
+        self.module.save_answer({'student_answer': 'answer 4'}, 
+                                self.module.system)
         responses['assessment'] = '1'
-        self.module.save_assessment(mock_query_dict, test_system)
+        self.module.save_assessment(mock_query_dict, self.module.system)
         self.assertEqual(self.module.state, self.module.DONE)