Improve state creation to work better with has_code after check_file

- init more similar to protowhat State init
- cleaner to_child code

Author: hermansje

pythonwhat/State.py

@@ -86,10 +86,11 @@ def __init__(
 
         self.ast_dispatcher = self.get_dispatcher()
 
-        # parse code if didn't happen yet
-        if student_ast is None:
+        # Parse solution and student code
+        # if possible, not done yet and wanted (ast arguments not False)
+        if isinstance(self.student_code, str) and student_ast is None:
             self.student_ast = self.parse(student_code)
-        if solution_ast is None:
+        if isinstance(self.solution_code, str) and solution_ast is None:
             self.solution_ast = self.parse(solution_code, test=False)
 
         if highlight is None:  # todo: check parent_state? (move check to reporting?)
@@ -123,41 +124,36 @@ def to_child(self, append_message="", node_name="", **kwargs):
 
         kwargs["messages"] = [*self.messages, append_message]
 
-        for kwarg in ["solution_context", "student_context"]:
-            if kwarg in kwargs and not kwargs[kwarg]:
-                kwargs.pop(kwarg, None)
-
         def update_kwarg(name, func):
             kwargs[name] = func(kwargs[name])
 
         def update_context(name):
             update_kwarg(name, getattr(self, name).update_ctx)
 
-        if isinstance(kwargs.get("student_ast", None), list):
-            update_kwarg("student_ast", wrap_in_module)
-        if isinstance(kwargs.get("solution_ast", None), list):
-            update_kwarg("solution_ast", wrap_in_module)
+        for ast_arg in ["student_ast", "solution_ast"]:
+            if isinstance(kwargs.get(ast_arg), list):
+                update_kwarg(ast_arg, wrap_in_module)
 
-        if "student_ast" in kwargs:
+        if kwargs.get("student_ast") and kwargs.get("student_code") is None:
             kwargs["student_code"] = self.student_ast_tokens.get_text(
                 kwargs["student_ast"]
             )
-        if "solution_ast" in kwargs:
+        if kwargs.get("solution_ast") and kwargs.get("solution_code") is None:
             kwargs["solution_code"] = self.solution_ast_tokens.get_text(
                 kwargs["solution_ast"]
             )
 
-        # get new contexts
-        if "solution_context" in kwargs:
-            update_context("solution_context")
-        if "student_context" in kwargs:
-            update_context("student_context")
-
-        # get new envs
-        if "solution_env" in kwargs:
-            update_context("solution_env")
-        if "student_env" in kwargs:
-            update_context("student_env")
+        for context in [
+            "student_context",
+            "solution_context",
+            "student_env",
+            "solution_env",
+        ]:
+            if context in kwargs:
+                if kwargs[context] is not None:
+                    update_context(context)
+                else:
+                    kwargs.pop(context)
 
         klass = self.SUBCLASSES[node_name] if node_name else State
         child = klass(**{**base_kwargs, **kwargs})

tests/test_check_files.py

@@ -8,22 +8,81 @@
 from protowhat.checks import check_files as cf
 
 
-@pytest.fixture(scope="function")
-def tf():
+@pytest.fixture
+def temp_py_file():
     with NamedTemporaryFile() as tmp:
-        tmp.file.write(b"1 + 1")
+        tmp.file.write(
+            b"""
+if True:
+    a = 1"""
+        )
         tmp.file.flush()
         yield tmp
 
 
-def test_file_existence(tf):
-    s = setup_state("", "", pec="")
+@pytest.fixture
+def temp_txt_file():
+    with NamedTemporaryFile() as tmp:
+        tmp.file.write(b"this is a text file")
+        tmp.file.flush()
+        yield tmp
+
+
+@pytest.fixture(params=["temp_py_file", "temp_txt_file"])
+def temp_file(request):
+    return request.getfuncargvalue(request.param)
+
+
+def test_python_file_existence(temp_py_file):
+    expected_content = cf.get_file_content(temp_py_file.name)
+    chain = setup_state("", "", pec="")
+
+    # test with just student content
+    child = cf.check_file(chain._state, temp_py_file.name)
+    assert expected_content in child.student_code
+    assert child.student_ast is not None
+    assert child.solution_code is None
+    assert child.solution_ast is None
 
-    child = cf.check_file(s._state, tf.name)
-    assert "1 + 1" in child.student_code
+    # test with solution content
+    child = cf.check_file(
+        chain._state, temp_py_file.name, solution_code=expected_content
+    )
+    assert expected_content in child.student_code
+    assert child.student_ast is not None
+    assert expected_content in child.solution_code
+    assert child.solution_ast is not None
 
-    file_chain = s.check_file(tf.name)
-    assert "1 + 1" in file_chain._state.student_code
+
+def test_file_existence_syntax(temp_py_file):
+    """test integration of protowhat checks in pythonwhat"""
+    expected_content = cf.get_file_content(temp_py_file.name)
+    chain = setup_state("", "", pec="")
+
+    file_chain = chain.check_file(temp_py_file.name)
+    assert expected_content in file_chain._state.student_code
 
     with helper.verify_sct(True):
-        s >> F(attr_scts={"check_file": cf.check_file}).check_file(tf.name)
+        file_chain = chain >> F(attr_scts={"check_file": cf.check_file}).check_file(
+            temp_py_file.name
+        )
+        assert expected_content in file_chain._state.student_code
+
+
+def test_file_parsing(temp_py_file):
+    expected_content = cf.get_file_content(temp_py_file.name)
+    chain = setup_state("", "", pec="")
+
+    file_chain = chain.check_file(temp_py_file.name, solution_code=expected_content)
+    file_chain.check_if_else().check_test().has_equal_value()
+    file_chain.check_if_else().check_test().has_equal_value(expr_code="False")
+
+
+def test_file_content(temp_file):
+    expected_content = cf.get_file_content(temp_file.name)
+    chain = setup_state("", "", pec="")
+
+    chain.check_file(temp_file.name, parse=False).has_code(expected_content)
+    chain.check_file(
+        temp_file.name, parse=False, solution_code=expected_content
+    ).has_code(expected_content)