Refactored sheerka class: splitted to use sub handlers. Refactored unit tests to use classes.

tests/evaluators/test_ConceptEvaluator.py

@@ -0,0 +1,117 @@
+import pytest
+
+from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
+from core.concept import Concept, ConceptParts
+from evaluators.ConceptEvaluator import ConceptEvaluator
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+
+
+class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):
+
+    @pytest.mark.parametrize("ret_val, expected", [
+        (ReturnValueConcept("some_name", True, ParserResultConcept(value=Concept())), True),
+        (ReturnValueConcept("some_name", False, ParserResultConcept(value=Concept())), False),
+        (ReturnValueConcept("some_name", True, ParserResultConcept(value="Not a concept")), False),
+        (ReturnValueConcept("some_name", True, Concept()), False),
+    ])
+    def test_i_can_match(self, ret_val, expected):
+        context = self.get_context()
+        assert ConceptEvaluator().matches(context, ret_val) == expected
+
+    def test_i_can_evaluate_concept(self):
+        context = self.get_context()
+        concept = Concept(name="foo",
+                          where="1",
+                          pre="2",
+                          post="3").def_prop("a", "4").def_prop("b", "5")
+
+        evaluator = ConceptEvaluator()
+        item = self.pretval(concept)
+        result = evaluator.eval(context, item)
+
+        assert result.who == evaluator.name
+        assert result.status
+        assert result.value.name == "foo"
+        assert result.value.get_metadata_value(ConceptParts.WHERE) == 1
+        assert result.value.get_metadata_value(ConceptParts.PRE) == 2
+        assert result.value.get_metadata_value(ConceptParts.POST) == 3
+        assert result.value.get_prop("a") == 4
+        assert result.value.get_prop("b") == 5
+        assert result.value.key == "foo"
+        assert result.parents == [item]
+
+    def test_body_is_returned_when_defined_and_requested(self):
+        context = self.get_context()
+        concept = Concept(name="foo",
+                          body="'I have a value'",
+                          where="1",
+                          pre="2",
+                          post="3").set_prop("a", "4").set_prop("b", "5")
+
+        evaluator = ConceptEvaluator(return_body=True)
+        item = self.pretval(concept)
+        result = evaluator.eval(context, item)
+
+        assert result.who == evaluator.name
+        assert result.status
+        assert result.value == "I have a value"
+        assert result.parents == [item]
+
+    def test_body_is_not_returned_if_not_requested(self):
+        context = self.get_context()
+        concept = Concept(name="foo",
+                          body="'I have a value'",
+                          where="1",
+                          pre="2",
+                          post="3").set_prop("a", "4").set_prop("b", "5")
+
+        evaluator = ConceptEvaluator(return_body=False)  # which is the default behaviour
+        item = self.pretval(concept)
+        result = evaluator.eval(context, item)
+
+        assert result.who == evaluator.name
+        assert result.status
+        assert result.value == concept
+        assert result.parents == [item]
+
+    def test_i_can_eval_if_with_the_same_name_is_defined_in_the_context(self):
+        # If we evaluate Concept("foo", body="a").set_prop("a", "'property_a'")
+        # ConceptEvaluator will be called to resolve 'a' while we know that 'a' refers to the string 'property_a'
+
+        context = self.get_context()
+        context.obj = Concept("other").set_prop("foo", "'some_other_value'")
+        concept = Concept(name="foo")
+
+        item = self.pretval(concept)
+        result = ConceptEvaluator().eval(context, item)
+
+        assert result.status
+        assert result.value == "'some_other_value'"
+
+    def test_i_cannot_recognize_a_concept_if_one_of_the_prop_is_unknown(self):
+        context = self.get_context()
+        context.sheerka.add_in_cache(Concept(name="one").init_key())
+        concept_plus = context.sheerka.add_in_cache(Concept(name="a plus b")
+                                                    .def_prop("a", "one")
+                                                    .def_prop("b", "two").init_key())
+
+        evaluator = ConceptEvaluator()
+        item = self.pretval(concept_plus)
+        result = evaluator.eval(context, item)
+
+        assert not result.status
+        assert context.sheerka.isinstance(result.value, BuiltinConcepts.CONCEPT_EVAL_ERROR)
+        assert result.value.concept == concept_plus
+        assert result.value.property_name == "b"
+        assert context.sheerka.isinstance(result.value.error, BuiltinConcepts.TOO_MANY_ERRORS)
+
+    def test_that_error_concepts_are_transformed_into_errors_only_if_the_key_is_different(self):
+        context = self.get_context()
+
+        error_concept = context.sheerka.new(BuiltinConcepts.ERROR)
+        item = self.pretval(error_concept)
+        result = ConceptEvaluator().eval(context, item)
+
+        assert not context.sheerka.is_success(error_concept)  # it's indeed an error
+        assert result.status
+        assert result.value == error_concept