Merge pull request #181 from datacamp/feature-override

Feature override

Author: machow

pythonwhat/check_funcs.py

@@ -179,7 +179,7 @@ def test_not(*args, msg, state=None):
         return state
 
     _msg = state.build_message(msg)
-    return rep.do_test(Test(msg))
+    return rep.do_test(Test(_msg))
 
 # utility functions -----------------------------------------------------------
 
@@ -194,10 +194,39 @@ def fail(msg="", state=None):
     """Fail test with message"""
     rep = Reporter.active_reporter
     _msg = state.build_message(msg)
-    rep.do_test(Test(Feedback(msg, state.highlight)))
+    rep.do_test(Test(Feedback(_msg, state.highlight)))
 
     return state
 
+import ast
+def override(solution, state=None):
+    """Change the focused solution code."""
+
+    # the old ast may be a number of node types, but generally either a
+    # (1) ast.Module, or for single expressions...
+    # (2) whatever was grabbed using module.body[0]
+    # (3) module.body[0].value, when module.body[0] is an Expr node
+    old_ast = state.solution_tree
+    new_ast = ast.parse(solution)
+    if not isinstance(old_ast, ast.Module) and len(new_ast.body) == 1:
+        expr = new_ast.body[0]
+        candidates = [expr, expr.value] if isinstance(expr, ast.Expr) else [expr]
+        for node in candidates:
+            if isinstance(node, old_ast.__class__): 
+                new_ast = node
+                break
+
+    kwargs  = state.messages[-1] if state.messages else {}
+    child = state.to_child_state(
+            solution_subtree = new_ast,
+            student_subtree = state.student_tree,
+            highlight = state.highlight,
+            append_message = {'msg': "", 'kwargs': kwargs}
+            )
+
+    return child
+    
+
 # context functions -----------------------------------------------------------
 
 from pythonwhat.tasks import setUpNewEnvInProcess, breakDownNewEnvInProcess

pythonwhat/check_wrappers.py

@@ -58,7 +58,7 @@
 
 for k in ['set_context', 
           'has_equal_value', 'has_equal_output', 'has_equal_error', 'has_equal_ast', 'call',
-          'extend', 'multi', 'test_not', 'fail', 'quiet',
+          'extend', 'multi', 'test_not', 'fail', 'quiet', 'override',
           'with_context',
           'check_args',
           'has_equal_part']:

pythonwhat/parsing.py

@@ -608,6 +608,9 @@ def parse_node(cls, node):
         kwargs = cls.get_arg_part(node.args.kwarg, None, 'kwarg')
         all_args = [*args, varargs, *kw_args, kwargs]
 
+        if isinstance(node, ast.Lambda): body_node = node.body
+        else: body_node = FunctionBodyTransformer().visit(ast.Module(node.body))
+
         return {
             "node": node,
             "name": getattr(node, 'name', None),
@@ -616,7 +619,7 @@ def parse_node(cls, node):
             "_spec1_args": args,
             "*args": varargs,
             "**kwargs":  kwargs,
-            "body": {'node': FunctionBodyTransformer().visit(ast.Module(node.body)), 
+            "body": {'node': body_node, 
                      'target_vars': TargetVars(target_vars)}
         }
 

tests/test_spec.py

@@ -173,6 +173,76 @@ def test_fail(self):
         self.assertFalse(sct_payload['correct'])
 
 
+class TestOverride(unittest.TestCase):
+    """
+    This class is used to test overriding w/ correct and incorrect code. Tests are 
+    run for entire nodes (e.g. an if block) and their parts (e.g. body of if block)
+    """
+
+    def do_exercise(self, code, base_check, parts, override=None, part_name = None, part_index = "", passes=True):
+        """High level function used to generate tests"""
+        if part_name:
+            if not override: override = parts[part_name]
+            sct = base_check + '.check_{}({}).override("""{}""").has_equal_ast()'\
+                        .format(part_name, part_index, override)
+        else:
+            # whole code (e.g. if expression, or for loop)
+            if not override: override = code.format(**parts)
+            sct = base_check + '.override("""{}""").has_equal_ast()'.format(override)
+        
+        data = {
+                "DC_SOLUTION": code.format(**parts),
+                "DC_CODE": code.format(**parts),
+                "DC_SCT": sct
+            }
+        sct_payload = helper.run(data)
+        self.assertTrue(sct_payload['correct']) if passes else self.assertFalse(sct_payload['correct'])
+
+    # used to generate tests
+    EXPRESSIONS = {
+            'if_exp': "{body} if {test} else {orelse}",
+            'list_comp': "[{body} for i in {iter}]",
+            'dict_comp': "{{ {key}: {value}  for i in {iter} }}",
+            'for_loop': "for i in {iter}: {body}",
+            'while': "while {test}: {body}",
+            'try_except': "try: {body}\nexcept: pass\nelse: {orelse}",
+            'lambda_function': "lambda a={args}: {body}",
+            'function_def': ["'sum'", "def sum(a={args}): {body}"],
+            'function': ["'sum', 0", "sum({args})"]
+            }
+
+    PARTS = {'body': "1", "test": "False", 'orelse': "2", 'iter': "range(3)", 
+             'key': "3", 'value': "4", 'args': "(1,2,3)"}
+
+import re
+def gen_exercise(*args, **kwargs):
+    return lambda self: TestOverride.do_exercise(self, *args, **kwargs)
+
+for k, code in TestOverride.EXPRESSIONS.items():
+    # base SCT, w/ special indexing if function checks
+    if isinstance(code, list): indx, code = code
+    else: indx = '0'
+    base_check = "Ex().check_{}({})".format(k, indx)
+    # pass overall test ----
+    pf = gen_exercise(code, base_check, TestOverride.PARTS)
+    setattr(TestOverride, 'test_{}_pass'.format(k), pf)
+    # fail overall test ----
+    pf = gen_exercise(code, base_check, TestOverride.PARTS, override="'WRONG ANSWER'", passes=False)
+    setattr(TestOverride, 'test_{}_fail'.format(k), pf)
+    # test individual pieces --------------------------------------------------
+    for part in re.findall("\{([^{]*?)\}", code):    # find all str.format vars, e.g. {body}
+        part_index = "" if part != 'args' else 0
+        # pass individual piece ----
+        test_name = 'test_{}_{}_pass'.format(k, part)
+        pf = gen_exercise(code, base_check, TestOverride.PARTS, part_name=part, part_index=part_index)
+        setattr(TestOverride, test_name, pf) 
+        # fail individual piece ----
+        test_name = 'test_{}_{}_fail'.format(k, part)
+        bad_code = code.format(**{part: "[]", **TestOverride.PARTS})
+        pf = gen_exercise(code, base_check, TestOverride.PARTS, part_name=part, part_index=part_index, override=bad_code, passes=False)
+        setattr(TestOverride, test_name, pf) 
+
+
 #class TestSetContext(unittest.TestCase):
 #    def setUp(self):
 #        self.data = {

tests/test_test_function.py

@@ -757,17 +757,26 @@ def test_pass_sig_false(self):
         sct_payload = helper.run(self.data)
         self.assertTrue(sct_payload['correct'])
 
-    @unittest.skip("TODO: implement override")
     def test_pass_sig_false_override(self):
         self.setup_color()
-        self.data["DC_SCT"].replace('color', 'c')
+        self.data["DC_CODE"] = self.data["DC_CODE"].replace('color', 'c')
         self.data['DC_SCT'] =  """
-Ex().check_function('f', 0, signature=False).override("f(c = 'blue')").check_args('c').has_equal_ast()
+Ex().override("f(c = 'blue')").check_function('f', 0, signature=False).check_args('c').has_equal_ast()
 """
 
         sct_payload = helper.run(self.data)
         self.assertTrue(sct_payload['correct'])
 
+    @unittest.skip("TODO: override code isn't parsed, so can't get args part")
+    def test_pass_sig_false_override_after_check(self):
+        self.setup_color()
+        self.data["DC_CODE"] = self.data["DC_CODE"].replace('color', 'c')
+        self.data['DC_SCT'] =  """
+Ex().check_function('f', 0, signature=False).override("f(c = 'blue')").check_args('c').has_equal_ast()
+"""
+        sct_payload = helper.run(self.data)
+        self.assertTrue(sct_payload['correct'])
+
 
 class TestFunctionComplexArgs(unittest.TestCase):
     def setUp(self):