Fixed BNF concept evaluations

2020-01-03 19:19:57 +01:00
parent adcbc6bb2e
commit ffd98d7407
20 changed files with 682 additions and 237 deletions
@@ -0,0 +1,128 @@
+import pytest
+
+from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
+from core.concept import Concept
+from core.sheerka import Sheerka, ExecutionContext
+from evaluators.BaseEvaluator import BaseEvaluator
+from evaluators.ConceptComposerEvaluator import ConceptComposerEvaluator
+from parsers.BaseParser import BaseParser
+from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, Sequence
+from sdp.sheerkaDataProvider import Event
+
+concept_lexer_name = ConceptLexerParser().name
+
+
+def get_context():
+    sheerka = Sheerka(skip_builtins_in_db=True)
+    sheerka.initialize("mem://")
+    return ExecutionContext("test", Event(), sheerka)
+
+
+def get_return_values(context, grammar, expression):
+    parser = ConceptLexerParser()
+    parser.initialize(context, grammar)
+
+    ret_val = parser.parse(context, expression)
+    assert not ret_val.status
+    return [ret_val]
+
+
+def init(concepts, grammar, expression):
+    context = get_context()
+    for c in concepts:
+        context.sheerka.add_in_cache(c)
+    return_values = get_return_values(context, grammar, expression)
+
+    return context, return_values
+
+
+@pytest.mark.parametrize("return_values, expected", [
+    ([
+         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
+         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
+         ReturnValueConcept("not a parser", True, "some value"),
+     ], True),
+    ([
+         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
+     ], True),
+    ([
+         ReturnValueConcept(BaseParser.PREFIX + "some_name", True, "not in error"),
+         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
+     ], False),
+    ([
+         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
+         ReturnValueConcept(concept_lexer_name, True, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
+     ], False),
+    ([
+         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
+         ReturnValueConcept(concept_lexer_name, False, "some value"),
+     ], False),
+    ([
+         ReturnValueConcept(BaseParser.PREFIX + "some_name", False, "in error"),
+         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=["not a concept"])),
+     ], False),
+    ([
+         ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", False, "evaluator in error"),
+         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
+         ReturnValueConcept("not a parser", True, "some value"),
+     ], False),
+    ([
+         ReturnValueConcept(BaseEvaluator.PREFIX + "some_name", True, "evaluator"),
+         ReturnValueConcept(concept_lexer_name, False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])),
+         ReturnValueConcept("not a parser", True, "some value"),
+     ], False),
+])
+def test_i_can_match(return_values, expected):
+    context = get_context()
+    assert ConceptComposerEvaluator().matches(context, return_values) == expected
+
+
+def test_i_can_eval_simple_concepts():
+    foo = Concept("foo", body="'foo'")
+    bar = Concept("bar", body="'bar'")
+    grammar = {}
+    context, return_values = init([foo, bar], grammar, "bar foo")
+
+    composer = ConceptComposerEvaluator()
+    assert composer.matches(context, return_values)
+
+    ret_val = composer.eval(context, return_values)
+    assert ret_val.status
+    assert ret_val.who == composer.name
+    assert ret_val.value == [Concept("bar", body="bar").init_key(), Concept("foo", body="foo").init_key()]
+    assert ret_val.value[0].metadata.is_evaluated
+    assert ret_val.value[1].metadata.is_evaluated
+    assert ret_val.parents == [return_values[0]]
+
+
+def test_i_can_eval_simple_concepts_when_some_are_bnf():
+    foo = Concept("foo", body="'foo'")
+    bar = Concept("bar", body="'bar'")
+    grammar = {foo: "foo"}
+    context, return_values = init([foo, bar], grammar, "bar foo")
+
+    composer = ConceptComposerEvaluator()
+    assert composer.matches(context, return_values)
+
+    ret_val = composer.eval(context, return_values)
+    assert ret_val.status
+    assert ret_val.who == composer.name
+    assert ret_val.value == [Concept("bar", body="bar").init_key(), Concept("foo", body="foo").init_key()]
+    assert ret_val.value[0].metadata.is_evaluated
+    assert ret_val.value[1].metadata.is_evaluated
+    assert ret_val.parents == [return_values[0]]
+
+
+def test_i_can_eval_simple_concept_and_text():
+    foo = Concept("foo", body="'foo'")
+    grammar = {}
+    context, return_values = init([foo], grammar, "'bar' foo")
+
+    composer = ConceptComposerEvaluator()
+    assert composer.matches(context, return_values)
+
+    ret_val = composer.eval(context, return_values)
+    assert ret_val.status
+    assert ret_val.who == composer.name
+    assert ret_val.value == "bar foo"
+    assert ret_val.parents == [return_values[0]]