In PythonEvaluator, I now evaluate concept and/or concept body

tests/evaluators/test_PythonEvaluator.py

@@ -1,10 +1,10 @@
 import pytest
-
 from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
-from core.concept import Concept, DEFINITION_TYPE_DEF
+from core.concept import Concept, CB
 from core.sheerka.services.SheerkaExecute import ParserInput
-from evaluators.PythonEvaluator import PythonEvaluator
+from evaluators.PythonEvaluator import PythonEvaluator, PythonEvalError
 from parsers.PythonParser import PythonNode, PythonParser
+
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
 
 
@@ -63,7 +63,7 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         Concept("foo").def_var("prop", "'a'"),
         Concept("foo", body="bar")
     ])
-    def test_i_cannot_eval_simple_concept(self, concept):
+    def test_simple_concepts_are_not_for_me(self, concept):
         context = self.get_context()
         context.sheerka.add_in_cache(Concept("foo"))
 
@@ -73,7 +73,7 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert not evaluated.status
         assert context.sheerka.isinstance(evaluated.value, BuiltinConcepts.NOT_FOR_ME)
 
-    def test_i_can_eval_expression_with_that_references_concepts(self):
+    def test_i_can_eval_ast_expression_that_references_concepts(self):
         """
         I can test modules with variables
         :return:
@@ -87,7 +87,7 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.status
         assert evaluated.value == 3
 
-    def test_i_can_eval_module_with_that_references_concepts(self):
+    def test_i_can_eval_ast_module_that_references_concepts(self):
         """
         I can test modules with variables
         :return:
@@ -101,13 +101,12 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.status
         assert evaluated.value == Concept("foo").init_key()
 
-    def test_i_can_eval_module_with_that_references_concepts_with_body(self):
+    def test_i_can_eval_ast_module_that_references_concepts_with_body(self):
         """
         I can test modules with variables
         :return:
         """
-        context = self.get_context()
-        context.sheerka.add_in_cache(Concept("foo", body="2"))
+        sheerka, context, foo = self.init_concepts(Concept("foo", body="2"))
 
         parsed = PythonParser().parse(context, ParserInput("def a(b):\n    return b\na(foo)"))
         evaluated = PythonEvaluator().eval(context, parsed)
@@ -127,15 +126,6 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.status
         assert evaluated.value == "foo"
 
-        # sanity, does not work otherwise
-        parsed = PythonParser().parse(context, ParserInput("get_concept_name(foo)"))
-        python_evaluator = PythonEvaluator()
-        python_evaluator.globals["get_concept_name"] = get_concept_name
-        evaluated = python_evaluator.eval(context, parsed)
-
-        assert not evaluated.status
-        assert evaluated.body.body.args[0] == "'int' object has no attribute 'name'"
-
     def test_i_can_call_function_with_complex_concepts(self):
         sheerka, context, plus, mult = self.init_concepts(
             self.from_def_concept("plus", "a plus b", ["a", "b"]),
@@ -163,23 +153,52 @@ class TestPythonEvaluator(TestUsingMemoryBasedSheerka):
         assert evaluated.status
         assert evaluated.body == 10
 
-    # @pytest.mark.parametrize("text, concept_key, concept_id, use_concept", [
-    #     ("__C__key__C__", "key", None, False),
-    #     ("__C__key__id__C__", "key", "id", False),
-    #     ("__C__USE_CONCEPT__key__id__C__", "key", "id", True),
-    #     ("__C__USE_CONCEPT__key__id__C__", "key", "id", True),
-    # ])
-    # def test_i_can_resolve_name(self, text, concept_key, concept_id, use_concept):
-    #     context = self.get_context()
-    #     assert PythonEvaluator().resolve_name(context, text) == (concept_key, concept_id, use_concept)
-    #
-    # @pytest.mark.parametrize("text", [
-    #     "__C__",
-    #     "__C__key",
-    #     "__C__key____",
-    #     "__C____",
-    #     "__C__USE_CONCEPT__",
-    # ])
-    # def test_i_cannot_resolve_name(self, text):
-    #     context = self.get_context()
-    #     assert PythonEvaluator().resolve_name(context, text) is None
+    def test_i_can_get_all_possibles_globals(self):
+        sheerka, context, foo = self.init_concepts(Concept("foo", body="foo").auto_init())
+        python_evaluator = PythonEvaluator()
+        my_globals = {
+            "a": "a string",
+            "b": self.test_i_can_get_all_possibles_globals,
+            "foo": foo
+        }
+
+        all_globals = python_evaluator.get_all_possible_globals(context, my_globals)
+        assert len(all_globals) == 2
+        assert all_globals[0]["foo"] == 'foo'
+        assert all_globals[1]["foo"] == CB(foo, "foo")  # body is evaluated
+
+    def test_i_can_detect_one_error(self):
+        sheerka, context, foo = self.init_concepts("foo")
+
+        parsed = PythonParser().parse(context, ParserInput("foo + 1"))
+        evaluated = PythonEvaluator().eval(context, parsed)
+
+        assert not evaluated.status
+        assert context.sheerka.isinstance(evaluated.value, BuiltinConcepts.ERROR)
+
+        error = evaluated.body.body
+        assert isinstance(error, PythonEvalError)
+        assert isinstance(error.error, TypeError)
+        assert error.error.args[0] == "unsupported operand type(s) for +: 'Concept' and 'int'"
+        assert error.concepts == {'foo': foo}
+
+    def test_i_can_detect_multiple_errors(self):
+        sheerka, context, foo = self.init_concepts(Concept("foo", body="'string'"))
+
+        parsed = PythonParser().parse(context, ParserInput("foo + 1"))
+        evaluated = PythonEvaluator().eval(context, parsed)
+
+        assert not evaluated.status
+        assert context.sheerka.isinstance(evaluated.value, BuiltinConcepts.TOO_MANY_ERRORS)
+
+        error0 = evaluated.body.body[0]
+        assert isinstance(error0, PythonEvalError)
+        assert isinstance(error0.error, TypeError)
+        assert error0.error.args[0] == 'can only concatenate str (not "int") to str'
+        assert error0.concepts == {'foo': 'string'}
+
+        error1 = evaluated.body.body[1]
+        assert isinstance(error1, PythonEvalError)
+        assert isinstance(error1.error, TypeError)
+        assert error1.error.args[0] == "unsupported operand type(s) for +: 'Concept' and 'int'"
+        assert error1.concepts == {'foo': CB(foo, 'string')}