Sheerka-Old/tests/evaluators/test_AddConceptEvaluator.py

import ast
import pytest

from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
from core.concept import VARIABLE_PREFIX, Concept
from core.tokenizer import Tokenizer
from evaluators.AddConceptEvaluator import AddConceptEvaluator
from parsers.BaseParser import BaseParser
from parsers.ConceptLexerParser import Sequence, StrMatch, ZeroOrMore, ConceptExpression
from parsers.BnfParser import BnfParser
from parsers.DefaultParser import DefConceptNode, NameNode
from parsers.PythonParser import PythonNode, PythonParser

from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka


class TestAddConceptEvaluator(TestUsingMemoryBasedSheerka):

    @staticmethod
    def get_concept_part(part):
        if isinstance(part, str):
            node = PythonNode(part, ast.parse(part, mode="eval"))
            return ReturnValueConcept(
                who="parsers.Default",
                status=True,
                value=ParserResultConcept(
                    source=part,
                    parser=PythonParser(),
                    value=node))

        if isinstance(part, PythonNode):
            return ReturnValueConcept(
                who="parsers.Default",
                status=True,
                value=ParserResultConcept(
                    source=part.source,
                    parser=PythonParser(),
                    value=part))

        if isinstance(part, ReturnValueConcept):
            return part

    @staticmethod
    def get_return_value(source, parsing_expression):
        return ReturnValueConcept(
            who="Parsers:RegexParser",
            status=True,
            value=ParserResultConcept(
                source=source,
                parser=BnfParser(),
                value=parsing_expression
            )
        )

    def get_def_concept(self, name, where=None, pre=None, post=None, body=None, definition=None):
        concept = DefConceptNode([], name=NameNode(list(Tokenizer(name))))

        if body:
            concept.body = self.get_concept_part(body)
        if where:
            concept.where = self.get_concept_part(where)
        if pre:
            concept.pre = self.get_concept_part(pre)
        if post:
            concept.post = self.get_concept_part(post)
        if definition:
            concept.definition = definition

        return ReturnValueConcept(BaseParser.PREFIX + "some_name", True, ParserResultConcept(value=concept))

    @pytest.mark.parametrize("ret_val, expected", [
        (ReturnValueConcept(BaseParser.PREFIX + "some_name", True, ParserResultConcept(value=DefConceptNode([]))),
         True),
        (ReturnValueConcept(BaseParser.PREFIX + "some_name", False, ParserResultConcept(value=DefConceptNode([]))),
         False),
        (ReturnValueConcept(BaseParser.PREFIX + "some_name", True, "not a ParserResultConcept"), False),
        (ReturnValueConcept(BaseParser.PREFIX + "some_name", True, ParserResultConcept()), False),
    ])
    def test_i_can_match(self, ret_val, expected):
        context = self.get_context()
        assert AddConceptEvaluator().matches(context, ret_val) == expected

    def test_that_the_source_is_correctly_set(self):
        context = self.get_context()
        def_concept_return_value = self.get_def_concept(
            name="hello a",
            definition=self.get_return_value("hello a", Sequence(StrMatch("hello"), StrMatch("a"))),
            where="isinstance(a, str )",
            pre="a is not None",
            body="print('hello' + a)")

        evaluated = AddConceptEvaluator().eval(context, def_concept_return_value)

        assert evaluated.status
        assert context.sheerka.isinstance(evaluated.body, BuiltinConcepts.NEW_CONCEPT)

        created_concept = evaluated.body.body
        assert created_concept.metadata.name == "hello a"
        assert created_concept.metadata.where == "isinstance(a, str )"
        assert created_concept.metadata.pre == "a is not None"
        assert created_concept.metadata.post is None
        assert created_concept.metadata.body == "print('hello' + a)"
        assert created_concept.metadata.definition == "hello a"

    def test_that_the_new_concept_is_correctly_saved_in_db(self):
        context = self.get_context()
        def_concept_return_value = self.get_def_concept(
            name="hello a",
            definition=self.get_return_value("hello a", Sequence(StrMatch("hello"), StrMatch("a"))),
            where="isinstance(a, str )",
            pre="a is not None",
            body="print('hello' + a)")

        # sanity. Make sure that the concept does not already exist
        from_db = context.sheerka.get("hello " + VARIABLE_PREFIX + "0")
        assert context.sheerka.isinstance(from_db, BuiltinConcepts.UNKNOWN_CONCEPT)

        AddConceptEvaluator().eval(context, def_concept_return_value)
        context.sheerka.concepts_cache = {}  # reset cache
        from_db = context.sheerka.get("hello " + VARIABLE_PREFIX + "0")

        assert from_db.metadata.key == f"hello {VARIABLE_PREFIX}0"
        assert from_db.metadata.name == "hello a"
        assert from_db.metadata.where == "isinstance(a, str )"
        assert from_db.metadata.pre == "a is not None"
        assert from_db.metadata.post is None
        assert from_db.metadata.body == "print('hello' + a)"
        assert from_db.metadata.definition == "hello a"
        assert len(from_db.metadata.props) == 1
        assert from_db.metadata.props[0] == ("a", None)
        assert "a" in from_db.props

        assert from_db.compiled == {}  # ast is not saved in db

    def test_i_can_get_props_from_python_node_when_long_name(self):
        ret_val = self.get_concept_part("isinstance(a, str)")
        context = self.get_context()

        assert AddConceptEvaluator.get_props(context.sheerka, ret_val, ["a", "b"]) == ["a"]

    def test_i_cannot_get_props_from_python_node_when_name_has_only_one_token(self):
        ret_val = self.get_concept_part("isinstance(a, str)")
        context = self.get_context()

        assert AddConceptEvaluator.get_props(context.sheerka, ret_val, ["a"]) == []

    def test_i_can_get_props_from_another_concept(self):
        concept = Concept("hello").def_prop("a").def_prop("b")
        ret_val = ReturnValueConcept(who="some_parser",
                                     status=True,
                                     value=ParserResultConcept(value=concept))

        assert AddConceptEvaluator.get_props(self.get_context(), ret_val, []) == ["a", "b"]

    def test_i_can_get_props_from_definition(self):
        parsing_expression = Sequence(ConceptExpression('mult'),
                                      ZeroOrMore(Sequence(StrMatch("+"), ConceptExpression("add"))))
        ret_val = self.get_return_value("mult (('+'|'-') add)?", parsing_expression)

        assert AddConceptEvaluator.get_props(self.get_context(), ret_val, []) == ["add", "mult"]

    def test_concept_that_references_itself_is_correctly_created(self):
        context = self.get_context()
        def_concept_as_return_value = self.get_def_concept("foo", body="foo")

        ret_val = AddConceptEvaluator().eval(context, def_concept_as_return_value)

        assert ret_val.status
        new_concept = ret_val.body.body
        assert new_concept.name == 'foo'
        assert new_concept.metadata.body == 'foo'
        assert new_concept.props == {}
        assert new_concept.metadata.props == []