105 lines
4.9 KiB
Python
105 lines
4.9 KiB
Python
import ast
|
|
import pytest
|
|
|
|
from core.builtin_concepts import ReturnValueConcept, ParserResultConcept, BuiltinConcepts
|
|
from core.concept import Concept, ConceptParts, DoNotResolve
|
|
from evaluators.LexerNodeEvaluator import LexerNodeEvaluator
|
|
from parsers.ConceptLexerParser import ConceptNode, ConceptLexerParser, StrMatch, UnrecognizedTokensNode, SourceCodeNode
|
|
from parsers.PythonParser import PythonNode
|
|
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
|
|
|
|
|
class TestLexerNodeEvaluator(TestUsingMemoryBasedSheerka):
|
|
|
|
def from_parsing(self, context, grammar, expression):
|
|
parser = ConceptLexerParser()
|
|
parser.initialize(context, grammar)
|
|
|
|
ret_val = parser.parse(context, 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(node, 0, 0, [], fragment))
|
|
else:
|
|
nodes.append(ConceptNode(fragment, 0, 0, [], fragment.name))
|
|
|
|
return ReturnValueConcept("somme_name", True, ParserResultConcept(value=nodes))
|
|
|
|
def init(self, concept, grammar, text):
|
|
context = self.get_context()
|
|
if isinstance(concept, list):
|
|
for c in concept:
|
|
context.sheerka.add_in_cache(c)
|
|
else:
|
|
context.sheerka.add_in_cache(concept)
|
|
ret_val = self.from_parsing(context, grammar, text)
|
|
node = ret_val.value.value[0]
|
|
|
|
return context, node
|
|
|
|
@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):
|
|
context = self.get_context()
|
|
assert LexerNodeEvaluator().matches(context, ret_val) == expected
|
|
|
|
def test_concept_is_returned_when_only_one_in_the_list(self):
|
|
foo = Concept("foo")
|
|
context = self.get_context()
|
|
context.sheerka.add_in_cache(foo)
|
|
|
|
ret_val = self.from_parsing(context, {foo: StrMatch("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 == Concept("foo").init_key()
|
|
assert return_value.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 == evaluator.name
|
|
assert result.status
|
|
assert context.sheerka.isinstance(wrapper, BuiltinConcepts.PARSER_RESULT)
|
|
assert wrapper.parser == evaluator
|
|
assert wrapper.source == "foo + 1"
|
|
|
|
assert return_value == PythonNode('foo + 1', ast.parse("__C__foo__C__ + 1", mode="eval"))
|
|
assert return_value.concepts == {"__C__foo__C__": foo}
|
|
assert result.parents == [ret_val]
|