refactor test object and friends to use check funcs

added unit test for issue #150
should complete issue #124

Author: machow

pythonwhat/parsing.py

@@ -426,9 +426,10 @@ def __init__(self):
     def visit_Name(self, node):
         if self.active_assignment is not None:
             if node.id not in self.out:
-                self.out[node.id] = [self.active_assignment]
+                self.out[node.id] = self.get_part(node, self.active_assignment)
             else:
-                self.out[node.id].append(self.active_assignment)
+                self.out[node.id]['highlight'] = None
+                self.out[node.id]['assignments'].append(self.active_assignment)
             self.active_assignment = None
 
     def visit_Attribute(self, node):
@@ -465,6 +466,20 @@ def visit_TryFinally(self, node):
         self.visit_each(node.body)
         self.visit_each(node.finalbody)
 
+    @staticmethod
+    def get_part(name_node, ass_node=None):
+        # either name node or simply str or name itself
+        name = getattr(name_node, 'id', name_node)
+        load_name = ast.Name(id=name, ctx=ast.Load())
+        ast.fix_missing_locations(load_name)
+        # 
+        return {'name': name,
+                'node': load_name,
+                'highlight': ass_node or name_node,
+                'assignments': [] if not ass_node else [ass_node]
+                }
+
+
 class IfParser(Parser):
     """Find if structures.
 

pythonwhat/test_funcs/test_data_frame.py

@@ -1,34 +1,31 @@
-from pythonwhat.State import State
 from pythonwhat.Reporter import Reporter
-from pythonwhat.Test import DefinedProcessTest, InstanceProcessTest, DefinedCollProcessTest, EqualValueProcessTest
-from pythonwhat.Feedback import Feedback
-from pythonwhat.tasks import isDefinedInProcess, isInstanceInProcess, getColumnsInProcess, getValueInProcess, ReprFail
+from pythonwhat.tasks import getColumnsInProcess
 from .test_object import check_object
 from .test_dictionary import is_instance, test_key, has_key
 
 import pandas as pd
 
-MSG_UNDEFINED = "Are you sure you defined the pandas DataFrame: `{name}`?"
-MSG_NOT_INSTANCE = "`{name}` is not a pandas DataFrame."
-MSG_KEY_MISSING = "There is no column `{key}` inside `{name}`."
-MSG_INCORRECT_VAL = "Column `{key}` of your pandas DataFrame, `{name}`, is not correct."
+MSG_UNDEFINED = "Are you sure you defined the pandas DataFrame: `{parent[sol_part][name]}`?"
+MSG_NOT_INSTANCE = "`{parent[sol_part][name]}` is not a pandas DataFrame."
+MSG_KEY_MISSING = "There is no column `{key}` inside `{parent[sol_part][name]}`."
+MSG_INCORRECT_VAL = "Column `{key}` of your pandas DataFrame, `{parent[sol_part][name]}`, is not correct."
 
 def test_data_frame(name,
                     columns=None,
-                    undefined_msg=MSG_UNDEFINED,
-                    not_data_frame_msg=MSG_NOT_INSTANCE,
-                    undefined_cols_msg=MSG_KEY_MISSING,
-                    incorrect_msg=MSG_INCORRECT_VAL,
+                    undefined_msg=None,
+                    not_data_frame_msg=None,
+                    undefined_cols_msg=None,
+                    incorrect_msg=None,
                     state=None):
     """Test a pandas dataframe.
     """
 
     rep = Reporter.active_reporter
     rep.set_tag("fun", "test_data_frame")
 
-    check_df(name, undefined_msg, not_data_frame_msg, state=state)
+    child = check_df(name, undefined_msg or MSG_UNDEFINED, not_data_frame_msg or MSG_NOT_INSTANCE, state=state)
 
-    sol_cols = getColumnsInProcess(name, state.solution_process)
+    sol_cols = getColumnsInProcess(name, child.solution_process)
     if sol_cols is None:
         raise ValueError("Something went wrong in figuring out the columns for %s in the solution process" % name)
 
@@ -37,19 +34,13 @@ def test_data_frame(name,
 
     for col in columns:
         # check if column available
-        test_key(name, col, incorrect_msg, undefined_cols_msg, state=state)
+        test_key(name, col, incorrect_msg or MSG_INCORRECT_VAL, undefined_cols_msg or MSG_KEY_MISSING, state=child)
 
 # Check functions -------------------------------------------------------------
 
-def check_df(name, undefined_msg, not_instance_msg, state=None):
-    rep = Reporter.active_reporter
-
-    # Check if defined
-    undefined_msg = undefined_msg.format(name=name)
-
-    # check but don't get solution object representation
-    state = check_object(name, undefined_msg, state=state)
+def check_df(name, undefined_msg=MSG_UNDEFINED, not_instance_msg=MSG_NOT_INSTANCE, state=None):
 
-    is_instance(name, pd.DataFrame, not_instance_msg, state=state)
+    child = check_object(name, undefined_msg, state=state)          # test defined
+    is_instance(name, pd.DataFrame, not_instance_msg, state=child)  # test instance
 
-    return state
+    return child

pythonwhat/test_funcs/test_dictionary.py

@@ -1,14 +1,13 @@
-from pythonwhat.State import State
 from pythonwhat.Reporter import Reporter
-from pythonwhat.Test import DefinedProcessTest, InstanceProcessTest, DefinedCollProcessTest, EqualValueProcessTest
+from pythonwhat.Test import InstanceProcessTest, DefinedCollProcessTest, EqualValueProcessTest
 from pythonwhat.Feedback import Feedback
-from pythonwhat.tasks import isDefinedInProcess, isInstanceInProcess, getKeysInProcess, getValueInProcess, isDefinedCollInProcess, ReprFail
+from pythonwhat.tasks import isInstanceInProcess, getKeysInProcess, getValueInProcess, isDefinedCollInProcess, ReprFail
 from .test_object import check_object
 
-MSG_UNDEFINED = "Are you sure you defined the dictionary `{name}`?"
-MSG_NOT_INSTANCE = "`{name}` is not a dictionary."
-MSG_KEY_MISSING = "Have you specified a key `{key}` inside `{name}`?"
-MSG_INCORRECT_VAL = "Have you specified the correct value for the key `{key}` inside `{name}`?"
+MSG_UNDEFINED = "Are you sure you defined the dictionary `{parent[sol_part][name]}`?"
+MSG_NOT_INSTANCE = "`{parent[sol_part][name]}` is not a dictionary."
+MSG_KEY_MISSING = "Have you specified a key `{key}` inside `{parent[sol_part][name]}`?"
+MSG_INCORRECT_VAL = "Have you specified the correct value for the key `{key}` inside `{parent[sol_part][name]}`?"
 
 def test_dictionary(name,
                     keys=None,
@@ -23,39 +22,33 @@ def test_dictionary(name,
     rep = Reporter.active_reporter
     rep.set_tag("fun", "test_dictionary")
 
-    check_dict(name, undefined_msg, not_dictionary_msg, state=state)
+    child = check_dict(name, undefined_msg or MSG_UNDEFINED, not_dictionary_msg or MSG_NOT_INSTANCE, state=state)
 
     # set keys or check if manual keys are valid
     if not keys: 
         keys = getKeysInProcess(name, state.solution_process)
 
     for key in keys:
         # check if key in dictionary
-        test_key(name, key, incorrect_value_msg, key_missing_msg, state=state)
+        test_key(name, key, incorrect_value_msg or MSG_INCORRECT_VAL, key_missing_msg or MSG_KEY_MISSING, state=child)
 
 # Check functions -------------------------------------------------------------
 
-def check_dict(name, undefined_msg, not_instance_msg, state=None):
-    rep = Reporter.active_reporter
-
-    # Check if defined
-    undefined_msg = undefined_msg.format(name=name)
-    _msg = state.build_message(undefined_msg)
-
-    # check but don't get solution object representation
-    state = check_object(name, _msg, state=state)
+def check_dict(name, undefined_msg=MSG_UNDEFINED, not_instance_msg=MSG_NOT_INSTANCE, state=None):
 
-    is_instance(name, dict, not_instance_msg, state=state)
+    child = check_object(name, undefined_msg, state=state)   # test defined
+    is_instance(name, dict, not_instance_msg, state=child)   # test instance
 
-    return state
+    return child
 
 def is_instance(name, inst, not_instance_msg, state=None):
     rep = Reporter.active_reporter
 
     if not isInstanceInProcess(name, inst, state.solution_process):
         raise ValueError("%r is not a %s in the solution environment" % (name, type(inst)))
 
-    feedback = Feedback(not_instance_msg.format(name=name))
+    _msg = state.build_message(not_instance_msg)
+    feedback = Feedback(_msg, state.highlight)
     rep.do_test(InstanceProcessTest(name, inst, state.student_process, feedback))
 
 def has_key(name, key, key_missing_msg, state=None):
@@ -65,8 +58,9 @@ def has_key(name, key, key_missing_msg, state=None):
         raise NameError("Not all keys you specified are actually keys in %s in the solution process" % name)
 
     # check if key available
-    msg = key_missing_msg.format(key=key, name=name)
-    rep.do_test(DefinedCollProcessTest(name, key, state.student_process, Feedback(msg)))
+    _msg = state.build_message(key_missing_msg, {'key': key})
+    rep.do_test(DefinedCollProcessTest(name, key, state.student_process, 
+                                       Feedback(_msg, state.highlight)))
 
 def test_key(name, key, incorrect_value_msg, key_missing_msg, state=None):
     rep = Reporter.active_reporter
@@ -78,6 +72,5 @@ def test_key(name, key, incorrect_value_msg, key_missing_msg, state=None):
         raise NameError("Value from %r can't be fetched from the solution process: %s" % c(name, sol_value.info))
 
     # check if value ok
-    msg = incorrect_value_msg.format(key=key, name=name)
-    _msg = state.build_message(msg)
-    rep.do_test(EqualValueProcessTest(name, key, state.student_process, sol_value, Feedback(_msg)))
+    _msg = state.build_message(incorrect_value_msg, {'key': key})
+    rep.do_test(EqualValueProcessTest(name, key, state.student_process, sol_value, Feedback(_msg, state.highlight)))

pythonwhat/test_funcs/test_object.py

@@ -1,8 +1,13 @@
+import ast
+from pythonwhat.parsing import ObjectAssignmentParser
 from pythonwhat.Test import DefinedProcessTest, EqualProcessTest
-from pythonwhat.State import State
 from pythonwhat.Reporter import Reporter
 from pythonwhat.Feedback import Feedback
-from pythonwhat.tasks import isDefinedInProcess, getRepresentation, ReprFail
+from pythonwhat.tasks import isDefinedInProcess, getRepresentation
+from pythonwhat.check_funcs import part_to_child, has_equal_value
+
+MSG_UNDEFINED = "Have you defined `{parent[sol_part][name]}`?"
+MSG_INCORRECT = "The contents of `{parent[sol_part][name]}` aren't correct."
 
 def test_object(name,
                 eq_condition="equal",
@@ -44,10 +49,11 @@ def test_object(name,
     rep = Reporter.active_reporter
     rep.set_tag("fun", "test_object")
 
-    state = check_object(name, undefined_msg, do_eval=do_eval, state=state)
+    child = check_object(name, undefined_msg or MSG_UNDEFINED, state=state)
 
     if do_eval:
-        is_equal(name, incorrect_msg, state)
+
+        has_equal_value(incorrect_msg or MSG_INCORRECT, state=child)
 
 def get_assignment_node(obj_ass, name):
     nodes = obj_ass[name] if name in obj_ass else None
@@ -58,39 +64,21 @@ def get_assignment_node(obj_ass, name):
 
 # Check functions -------------------------------------------------------------
 
-MSG_UNDEFINED = "Have you defined `{name}`?"
-MSG_INCORRECT = "The contents of `{name}` aren't correct."
-
-def check_object(name, undefined_msg, do_eval=True, state=None):
+def check_object(name, undefined_msg=MSG_UNDEFINED, state=None):
     rep = Reporter.active_reporter
-    if not undefined_msg:
-        undefined_msg = MSG_UNDEFINED.format(name=name)
 
     if not isDefinedInProcess(name, state.solution_process):
         raise NameError("%r not in solution environment " % name)
 
-    _msg = state.build_message(undefined_msg)
-    rep.do_test(DefinedProcessTest(name, state.student_process, Feedback(_msg)))
-
-    if do_eval:
-        sol_obj = getRepresentation(name, state.solution_process)
-        if isinstance(sol_obj, ReprFail):
-            raise NameError(sol_obj.info)
-
-        state.solution_object = sol_obj
-
-    return state
-
-def is_equal(name, incorrect_msg, state=None):
-    rep = Reporter.active_reporter
-    if not incorrect_msg:
-        incorrect_msg = MSG_INCORRECT.format(name=name)
+    # create child state, using either parser output, or create part from name
+    fallback = lambda: ObjectAssignmentParser.get_part(name)
+    stu_part = state.student_object_assignments.get(name, fallback())
+    sol_part = state.solution_object_assignments.get(name, fallback())
+    
+    child = part_to_child(stu_part, sol_part, {'msg': '', 'kwargs': {}}, state)
 
-    ass_node = get_assignment_node(state.student_object_assignments, name)
-    _msg = state.build_message(incorrect_msg)
-    rep.do_test(EqualProcessTest(name,
-                                 state.student_process,
-                                 state.solution_object,
-                                 Feedback(_msg, ass_node)))
-    return state
+    # test object exists
+    _msg = child.build_message(undefined_msg)
+    rep.do_test(DefinedProcessTest(name, child.student_process, Feedback(_msg)))
 
+    return child

pythonwhat/test_funcs/test_object_after_expression.py

@@ -73,7 +73,7 @@ def test_object_after_expression(name,
     if not incorrect_msg:
         incorrect_msg = "Are you sure you assigned the correct value to `%s`?" % name
 
-    ass_node = get_assignment_node(state.student_object_assignments, name)
+    ass_node = state.student_object_assignments.get(name, {}).get('highlight')
 
     has_equal_value(
             incorrect_msg = incorrect_msg,

tests/test_instructor_warnings.py

@@ -8,7 +8,7 @@ def test_converter_err(self):
                 "DC_SCT": """set_converter('builtins.dict', lambda: abc); test_object('d') """
                 }
         data['DC_CODE'] = data['DC_SOLUTION']
-        self.assertRaises(NameError, lambda: helper.run(data))
+        self.assertRaises(ValueError, lambda: helper.run(data))
 
 if __name__ == "__main__":
     unittest.main()

tests/test_test_data_frame.py

@@ -90,6 +90,7 @@ def test_Fail2(self):
         sct_payload = helper.run(self.data)
         self.assertFalse(sct_payload['correct'])
         self.assertEqual(sct_payload['message'], 'Column <code>b</code> of your pandas DataFrame, <code>df</code>, is not correct.')
+        helper.test_lines(self, sct_payload, 2, 6, 1, 2)
 
     def test_Fail3(self):
         self.data["DC_CODE"] = '''