129 lines
4.9 KiB
Python
129 lines
4.9 KiB
Python
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]]
|