Fixed #9 : I can parse 'def concept'

tests/evaluators/test_DefConceptEvaluator.py

@@ -0,0 +1,94 @@
+import pytest
+
+from base import BaseTest
+from common.global_symbols import NotInit
+from conftest import NewOntology
+from core.BuiltinConcepts import BuiltinConcepts
+from evaluators.DefConceptEvaluator import DefConceptEvaluator
+from evaluators.RecognizeDefConcept import RecognizeDefConcept
+from helpers import _rv, _rvf, get_concepts
+from parsers.ConceptDefinitionParser import ConceptDefinition
+from parsers.ParserInput import ParserInput
+from parsers.parser_utils import UnexpectedEof
+
+
+def get_ret_val_from(context, command):
+    pi = ParserInput(command)
+    pi.init()
+    parser_start = _rv(context.sheerka.newn(BuiltinConcepts.PARSER_INPUT, pi=pi))
+    ret = RecognizeDefConcept().eval(context, None, parser_start)
+    return ret.new[0]
+
+
+class TestDefConceptEvaluator(BaseTest):
+    @pytest.fixture()
+    def evaluator(self, sheerka):
+        return sheerka.evaluators[DefConceptEvaluator.NAME]
+
+    def test_i_can_match(self, sheerka, context, evaluator):
+        ret_val = _rv(ConceptDefinition(name="foo"))
+        assert evaluator.matches(context, ret_val).status is True
+
+        ret_val = _rv("Not a ConceptDefinition class")
+        assert evaluator.matches(context, ret_val).status is False
+
+        ret_val = _rvf(ConceptDefinition(name="foo"))  # status is false
+        assert evaluator.matches(context, ret_val).status is False
+
+    def test_i_can_add_a_new_concept(self, context, evaluator):
+        ret_val_input = get_ret_val_from(context, "def concept foo")
+        res = evaluator.eval(context, None, ret_val_input)
+
+        assert len(res.new) == 1
+        assert res.new[0].status
+        assert context.sheerka.isinstance(res.new[0].value, BuiltinConcepts.NEW_CONCEPT)
+        assert res.eaten == [ret_val_input]
+
+    def test_i_cannot_add_when_definition_validation_fails(self, context, evaluator):
+        ret_val_input = get_ret_val_from(context, "def concept foo from bnf a |")  # only one '|' is required
+        res = evaluator.eval(context, None, ret_val_input)
+
+        assert len(res.new) == 1
+        assert not res.new[0].status
+        assert isinstance(res.new[0].value.value, UnexpectedEof)
+        assert res.eaten == []
+
+    @pytest.mark.parametrize("concept_def, expected", [
+        (ConceptDefinition(name="inc a", ret="a"), [("a", NotInit)]),
+        (ConceptDefinition(name="inc a", where="isinstance(a, int)"), [("a", NotInit)]),
+        (ConceptDefinition(name="inc a", def_var=[("a", 10)]), [("a", 10)]),
+        (ConceptDefinition(name="inc a", def_var=["a"]), [("a", NotInit)]),
+        (ConceptDefinition(name="a + b", where="a is an int", ret="b"), [("a", NotInit), ("b", NotInit)]),
+        (ConceptDefinition(name="b + a", where="a is an int", ret="b"), [("b", NotInit), ("a", NotInit)]),
+    ])
+    def test_i_can_get_variables(self, context, evaluator, concept_def, expected):
+        assert evaluator._get_variables(context, concept_def) == expected
+
+    def test_concept_name_is_not_considered_as_variable(self, context, evaluator):
+        with NewOntology(context, "test_concept_name_is_not_considered_as_variable"):
+            get_concepts(context, "one", use_sheerka=True)
+
+            concept_def = ConceptDefinition(name="add one + a", where="one is an int")
+            assert evaluator._get_variables(context, concept_def) == []
+
+    @pytest.mark.parametrize("concept_def, expected", [
+        ("def concept add a b where a and b", [("a", NotInit), ("b", NotInit)]),
+        ("def concept add a b where a ret b", [("a", NotInit), ("b", NotInit)]),
+        ("def concept add a b where xxx a and yyy b", [("a", NotInit), ("b", NotInit)]),
+        ("def concept add b a where xxx a and yyy b", [("b", NotInit), ("a", NotInit)]),
+        ("def concept add a b def_var a,b", [("a", NotInit), ("b", NotInit)]),
+        ("def concept add a b def_var a b", [("a", NotInit), ("b", NotInit)]),
+        ("def concept add a b def_var a def_var b", [("a", NotInit), ("b", NotInit)]),
+        ("def concept add a b def_var a=10 def_var b", [("a", 10), ("b", NotInit)]),
+        ("def concept add a b def_var a='hello' def_var b", [("a", "'hello'"), ("b", NotInit)]),
+    ])
+    def test_i_can_add_a_new_concept_with_variables(self, context, evaluator, concept_def, expected):
+        with NewOntology(context, "test_i_can_add_a_new_concept_with_variables"):
+            ret_val_input = get_ret_val_from(context, concept_def)
+            res = evaluator.eval(context, None, ret_val_input)
+
+            assert len(res.new) == 1
+            assert res.new[0].status
+            new_concept = res.new[0].value
+            assert context.sheerka.isinstance(new_concept, BuiltinConcepts.NEW_CONCEPT)
+            assert new_concept.body.variables == expected