93 lines
4.6 KiB
Python
93 lines
4.6 KiB
Python
import ast
|
|
|
|
import pytest
|
|
from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
|
|
from core.concept import Concept, ConceptParts, DoNotResolve
|
|
from core.sheerka.services.SheerkaExecute import ParserInput
|
|
from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
|
|
from parsers.BaseNodeParser import SourceCodeNode, ConceptNode, UnrecognizedTokensNode
|
|
from parsers.BnfNodeParser import BnfNodeParser
|
|
from parsers.PythonParser import PythonNode
|
|
|
|
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
|
|
|
|
|
class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
|
|
|
|
def init_from_concepts(self, context, concepts, expression):
|
|
parser = BnfNodeParser()
|
|
parser.init_from_concepts(context, concepts)
|
|
|
|
ret_val = parser.parse(context, ParserInput(expression))
|
|
assert ret_val.status
|
|
return ret_val
|
|
|
|
def from_fragments(self, *fragments):
|
|
nodes = []
|
|
for fragment in fragments:
|
|
if isinstance(fragment, str):
|
|
node = PythonNode(fragment, ast.parse(fragment.strip(), mode="eval"))
|
|
nodes.append(SourceCodeNode(0, 0, [], fragment, node))
|
|
else:
|
|
nodes.append(ConceptNode(fragment, 0, 0, [], fragment.name))
|
|
|
|
return ReturnValueConcept("somme_name", True, ParserResultConcept(value=nodes))
|
|
|
|
@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=[SourceCodeNode(0, 0, [])])), True),
|
|
(ReturnValueConcept("some_name", True, ParserResultConcept(value=SourceCodeNode(0, 0, []))), True),
|
|
(ReturnValueConcept("some_name", True, ParserResultConcept(value=[UnrecognizedTokensNode(0, 0, [])])), False),
|
|
(ReturnValueConcept("some_name", True, ParserResultConcept(value=UnrecognizedTokensNode(0, 0, []))), False),
|
|
(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=[SourceCodeNode(0, 0, [])])), False),
|
|
(ReturnValueConcept("some_name", False, ParserResultConcept(value=SourceCodeNode(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(self, ret_val, expected):
|
|
sheerka = self.get_sheerka(singleton=True)
|
|
context = self.get_context(sheerka)
|
|
assert LexerNodeEvaluator().matches(context, ret_val) == expected
|
|
|
|
def test_concept_is_returned_when_only_one_in_the_list(self):
|
|
sheerka, context, foo = self.init_concepts(self.bnf_concept("foo"))
|
|
ret_val = self.init_from_concepts(context, [foo], "foo")
|
|
|
|
evaluator = LexerNodeEvaluator()
|
|
result = evaluator.eval(context, ret_val)
|
|
wrapper = result.body
|
|
return_value = result.body.body
|
|
|
|
assert result.who == evaluator.name
|
|
assert result.status
|
|
assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
|
|
assert wrapper.parser == evaluator
|
|
assert wrapper.source == "foo"
|
|
assert return_value == foo
|
|
assert return_value.get_compiled()[ConceptParts.BODY] == DoNotResolve("foo")
|
|
assert result.parents == [ret_val]
|
|
|
|
def test_concept_python_node_is_returned_when_source_code(self):
|
|
context = self.get_context()
|
|
foo = Concept("foo")
|
|
ret_val = self.from_fragments(foo, " + 1")
|
|
|
|
evaluator = LexerNodeEvaluator()
|
|
result = evaluator.eval(context, ret_val)
|
|
wrapper = result.body
|
|
return_value = result.body.body
|
|
|
|
assert result.who == "parsers.PythonWithConcepts"
|
|
assert result.status
|
|
assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
|
|
assert wrapper.source == "foo + 1"
|
|
|
|
assert return_value == PythonNode('__C__foo__C__ + 1', ast.parse("__C__foo__C__ + 1", mode="eval"), "foo + 1")
|
|
assert return_value.objects == {"__C__foo__C__": foo}
|
|
assert result.parents == [ret_val]
|