Sheerka-Old/tests/test_ConceptNodeEvaluator.py

import pytest

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept
from core.concept import Concept
from core.sheerka import Sheerka, ExecutionContext
from evaluators.ConceptNodeEvaluator import ConceptNodeEvaluator
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, Sequence, TerminalNode, \
    StrMatch, Optional, OrderedChoice, ZeroOrMore, UnrecognizedTokensNode
from sdp.sheerkaDataProvider import Event


def get_context():
    sheerka = Sheerka(skip_builtins_in_db=True)
    sheerka.initialize("mem://")
    return ExecutionContext("test", Event(), sheerka)


def get_return_value(nodes, source):
    return ReturnValueConcept(
        "some_name",
        True,
        ParserResultConcept(parser=ConceptLexerParser(),
                            source=source,
                            value=nodes,
                            try_parsed=nodes))


def get_concept_node(context, grammar, expression):
    parser = ConceptLexerParser()
    parser.initialize(context, grammar)

    res = parser.parse(context, expression)
    assert res.status
    return res.value.value[0]


@pytest.mark.parametrize("ret_val, expected", [
    (ReturnValueConcept("some_name", True, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])), True),
    (ReturnValueConcept("some_name", True, ParserResultConcept(value=ConceptNode(Concept(), 0, 0))), True),
    (ReturnValueConcept("some_name", True, ParserResultConcept(value=[UnrecognizedTokensNode(0, 0, [])])), True),
    (ReturnValueConcept("some_name", True, ParserResultConcept(value=UnrecognizedTokensNode(0, 0, []))), True),
    (ReturnValueConcept("some_name", False, ParserResultConcept(value=[ConceptNode(Concept(), 0, 0)])), False),
    (ReturnValueConcept("some_name", False, ParserResultConcept(value=ConceptNode(Concept(), 0, 0))), False),
    (ReturnValueConcept("some_name", False, ParserResultConcept(value=[UnrecognizedTokensNode(0, 0, [])])), False),
    (ReturnValueConcept("some_name", False, ParserResultConcept(value=UnrecognizedTokensNode(0, 0, []))), False),
    (ReturnValueConcept("some_name", True, ParserResultConcept(value="Not a concept node")), False),
    (ReturnValueConcept("some_name", True, ParserResultConcept(value=["Not a concept node"])), False),
    (ReturnValueConcept("some_name", True, [ConceptNode(Concept(), 0, 0)]), False),
    (ReturnValueConcept("some_name", True, ConceptNode(Concept(), 0, 0)), False),
])
def test_i_can_match(ret_val, expected):
    context = get_context()
    assert ConceptNodeEvaluator().matches(context, ret_val) == expected


def test_concept_is_returned_when_list_of_one_concept_node():
    foo = Concept("foo")
    context = get_context()
    context.sheerka.add_in_cache(foo)

    evaluator = ConceptNodeEvaluator()
    node = ConceptNode(foo, 0, 0, underlying=TerminalNode(StrMatch("foo"), 0, 0, "foo"))

    ret_val = get_return_value([node], "h")
    result = evaluator.eval(context, ret_val)

    assert result.who == evaluator.name
    assert result.status
    assert result.value == Concept("foo", body="foo").init_key()
    assert result.parents == [ret_val]


def test_concept_property_is_correctly_updated_for_str_match():
    context = get_context()

    foo = Concept("foo")
    concept_node = get_concept_node(context, {foo: StrMatch("foo", rule_name="variable")}, "foo")
    updated = ConceptNodeEvaluator().update_concept(context.sheerka, concept_node.concept, concept_node.underlying)

    assert "variable" in updated.props
    assert updated.props["variable"].value == "foo"


def test_concept_property_is_correctly_updated_for_sequence():
    context = get_context()

    foo = Concept("foo")
    grammar = {foo: Sequence("one", "two", rule_name="variable")}
    concept_node = get_concept_node(context, grammar, "one two")
    updated = ConceptNodeEvaluator().update_concept(context.sheerka, concept_node.concept, concept_node.underlying)

    assert "variable" in updated.props
    assert updated.props["variable"].value == "one two"


def test_concept_property_is_updated_for_str_in_sequence():
    context = get_context()

    foo = Concept("foo")
    grammar = {foo: Sequence(StrMatch("one", rule_name="s1"), StrMatch("two", rule_name="s2"), rule_name="variable")}
    concept_node = get_concept_node(context, grammar, "one two")

    updated = ConceptNodeEvaluator().update_concept(context.sheerka, concept_node.concept, concept_node.underlying)

    assert updated.props["variable"].value == "one two"
    assert updated.props["s1"].value == "one"
    assert updated.props["s2"].value == "two"


def test_concept_property_is_correctly_updated_for_optional():
    context = get_context()

    foo = Concept("foo")
    grammar = {foo: Sequence("one", Optional("two", rule_name="o"), rule_name="variable")}
    concept_node = get_concept_node(context, grammar, "one two")

    updated = ConceptNodeEvaluator().update_concept(
        context.sheerka,
        context.sheerka.new(concept_node.concept.key),
        concept_node.underlying)

    assert "variable" in updated.props
    assert updated.props["variable"].value == "one two"
    assert updated.props["o"].value == "two"


def test_concept_property_is_correctly_updated_for_zero_or_more():
    context = get_context()

    foo = Concept("foo")
    grammar = {foo: ZeroOrMore("one", rule_name="variable")}
    concept_node = get_concept_node(context, grammar, "one one one")

    updated = ConceptNodeEvaluator().update_concept(
        context.sheerka,
        context.sheerka.new(concept_node.concept.key),
        concept_node.underlying)

    assert "variable" in updated.props
    assert updated.props["variable"].value == "one one one"


def test_concept_property_is_correctly_updated_when_list_of_properties():
    context = get_context()

    foo = Concept("foo")
    grammar = {foo: Sequence(StrMatch("one", rule_name="s"), StrMatch("two", rule_name="s"), rule_name="variable")}
    concept_node = get_concept_node(context, grammar, "one two")

    updated = ConceptNodeEvaluator().update_concept(
        context.sheerka,
        context.sheerka.new(concept_node.concept.key),
        concept_node.underlying)

    assert updated.props["variable"].value == "one two"
    assert updated.props["s"].value == ["one", "two"]


def test_concept_property_is_correctly_updated_when_another_concept():
    context = get_context()

    foo = Concept("foo")
    bar = Concept("bar")
    context.sheerka.add_in_cache(foo)
    context.sheerka.add_in_cache(bar)
    grammar = {
        foo: Sequence("one", "two", rule_name="var"),
        bar: Sequence(foo, "three", rule_name="var")}
    concept_node = get_concept_node(context, grammar, "one two three")

    updated = ConceptNodeEvaluator().update_concept(
        context.sheerka,
        context.sheerka.new(concept_node.concept.key),
        concept_node.underlying)

    assert updated.props["var"].value == "one two three"
    assert updated.props["foo"].value == Concept("foo", body="one two").set_prop("var", "one two").init_key()


def test_concept_property_is_correctly_updated_when_concept_recursion_using_optional():
    context = get_context()

    number = Concept("number")
    add = Concept("add")
    context.sheerka.add_in_cache(number)
    context.sheerka.add_in_cache(add)
    grammar = {
        number: OrderedChoice("one", "two"),
        add: Sequence(number, Optional(Sequence(OrderedChoice("plus", "minus", rule_name="op"), add)))
    }
    concept_node = get_concept_node(context, grammar, "one plus two")

    updated = ConceptNodeEvaluator().update_concept(
        context.sheerka,
        context.sheerka.new(concept_node.concept.key),
        concept_node.underlying)

    assert updated.props["number"].value == Concept("number", body="one").init_key()
    assert updated.props["op"].value == "plus"
    expected_add = Concept("add", body="two").set_prop("number", Concept("number", body="two").init_key()).init_key()
    assert updated.props["add"].value == expected_add


def test_concept_property_is_correctly_updated_when_concept_recursion_using_zero_or_more():
    context = get_context()

    number = Concept("number")
    add = Concept("add")
    context.sheerka.add_in_cache(number)
    context.sheerka.add_in_cache(add)
    grammar = {
        number: OrderedChoice("one", "two", 'three'),
        add: Sequence(number, ZeroOrMore(Sequence(OrderedChoice("plus", "minus", rule_name="op"), number)))
    }
    concept_node = get_concept_node(context, grammar, "one plus two minus three")

    updated = ConceptNodeEvaluator().update_concept(
        context.sheerka,
        context.sheerka.new(concept_node.concept.key),
        concept_node.underlying,
        init_empty_body=True)

    assert updated.props["number"].value == [Concept("number", body="one").init_key(),
                                             Concept("number", body="two").init_key(),
                                             Concept("number", body="three").init_key()]
    assert updated.props["op"].value == ["plus", "minus"]