First version of explain. Creating a new parser was a wrong approach. Need to reimplement
This commit is contained in:
@@ -0,0 +1,205 @@
|
||||
import pytest
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from parsers.BaseParser import UnexpectedTokenErrorNode, UnexpectedEof
|
||||
from parsers.ExplainParser import ExplainParser, ExplanationNode, MultipleDigestError, ValueErrorNode, \
|
||||
RecurseDefNode, FormatLNode, UnionNode, FilterNode, FormatDNode
|
||||
from parsers.ExpressionParser import PropertyContainsNode, PropertyEqualsNode, TrueNode, AndNode, OrNode
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
class TestExplainParser(TestUsingMemoryBasedSheerka):
|
||||
def init_parser(self, **kwargs):
|
||||
sheerka = self.get_sheerka(singleton=True, **kwargs)
|
||||
context = self.get_context(sheerka)
|
||||
parser = ExplainParser()
|
||||
return sheerka, context, parser
|
||||
|
||||
def test_i_cannot_parse_empty_string(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
res = parser.parse(context, "")
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
|
||||
|
||||
def test_i_cannot_parse_if_not_for_me(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
text = "foo"
|
||||
res = parser.parse(context, text)
|
||||
not_for_me = res.body
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(not_for_me, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert not_for_me.body == text
|
||||
assert isinstance(not_for_me.reason[0], UnexpectedTokenErrorNode)
|
||||
|
||||
@pytest.mark.parametrize("text, digest, command, directives", [
|
||||
# ("explain", "", "explain", []),
|
||||
("explain digest", "digest", "explain digest", []),
|
||||
("explain -r 3", "", "explain -r 3", [RecurseDefNode(3)]),
|
||||
("explain digest -r 3", "digest", "explain digest -r 3", [RecurseDefNode(3)]),
|
||||
])
|
||||
def test_i_can_parse_explain_without_filter(self, text, digest, command, directives):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
res = parser.parse(context, text)
|
||||
parser_result = res.body
|
||||
explanation_node = res.body.body
|
||||
|
||||
assert res.status
|
||||
assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
|
||||
assert parser_result.parser.name == "parsers.Explain"
|
||||
assert parser_result.source == text
|
||||
|
||||
assert explanation_node.digest == digest
|
||||
assert explanation_node.command == command
|
||||
assert explanation_node.expr == UnionNode([FilterNode(TrueNode(), directives)])
|
||||
|
||||
def test_i_can_parse_using_filter(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
text = "explain -f a=b"
|
||||
res = parser.parse(context, text)
|
||||
parser_result = res.body
|
||||
explanation_node = res.body.body
|
||||
|
||||
assert res.status
|
||||
assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
|
||||
assert parser_result.parser.name == "parsers.Explain"
|
||||
assert parser_result.source == text
|
||||
|
||||
assert explanation_node.expr == UnionNode([
|
||||
FilterNode(TrueNode()),
|
||||
FilterNode(PropertyContainsNode("a", "b"))])
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("-f a==b", PropertyEqualsNode("a", "b")),
|
||||
("--filter a==b", PropertyEqualsNode("a", "b")),
|
||||
("-f a==b and c=d", AndNode(PropertyEqualsNode("a", "b"), PropertyContainsNode("c", "d"))),
|
||||
("-f a==b or c=d", OrNode(PropertyEqualsNode("a", "b"), PropertyContainsNode("c", "d"))),
|
||||
("-f a==b or c==d and e==f", OrNode(
|
||||
PropertyEqualsNode("a", "b"),
|
||||
AndNode(PropertyEqualsNode("c", "d"), PropertyEqualsNode("e", "f")))),
|
||||
("-f a==b and c==d or e==f", OrNode(
|
||||
AndNode(PropertyEqualsNode("a", "b"), PropertyEqualsNode("c", "d")),
|
||||
PropertyEqualsNode("e", "f"))),
|
||||
("-f (a==b or c==d) and e==f", AndNode(
|
||||
OrNode(PropertyEqualsNode("a", "b"), PropertyEqualsNode("c", "d")),
|
||||
PropertyEqualsNode("e", "f"))),
|
||||
])
|
||||
def test_i_can_parse_filter_expressions(self, text, expected):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
res = parser.parse(context, "explain " + text)
|
||||
parser_result = res.body
|
||||
explanation_node = res.body.body
|
||||
expr_node = explanation_node.expr.filters[-1].expr
|
||||
|
||||
assert res.status
|
||||
assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
|
||||
assert isinstance(explanation_node, ExplanationNode)
|
||||
|
||||
assert expr_node == expected
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("-r 2", [
|
||||
FilterNode(TrueNode(), [RecurseDefNode(2)])
|
||||
]),
|
||||
("--format_l 'abc'", [
|
||||
FilterNode(TrueNode(), [FormatLNode('abc')])
|
||||
]),
|
||||
("--format_d 'abc'", [
|
||||
FilterNode(TrueNode(), [FormatDNode({"abc": "{abc}"})])
|
||||
]),
|
||||
("--format_d a,b,c", [
|
||||
FilterNode(TrueNode(), [FormatDNode({"a": "{a}", "b": "{b}", "c": "{c}"})])
|
||||
]),
|
||||
("--format_d a , b , c", [
|
||||
FilterNode(TrueNode(), [FormatDNode({"a": "{a}", "b": "{b}", "c": "{c}"})])
|
||||
]),
|
||||
("-r 2 --format_l 'abc'", [
|
||||
FilterNode(TrueNode(), [RecurseDefNode(2), FormatLNode('abc')])
|
||||
]),
|
||||
("--format_d a, b -r 2", [
|
||||
FilterNode(TrueNode(), [FormatDNode({"a": "{a}", "b": "{b}"}), RecurseDefNode(2)])
|
||||
]),
|
||||
("-f a==b -r 3", [
|
||||
FilterNode(TrueNode()),
|
||||
FilterNode(PropertyEqualsNode("a", "b"), [RecurseDefNode(3)]),
|
||||
]),
|
||||
("-f a==b --format_l 'abc'", [
|
||||
FilterNode(TrueNode()),
|
||||
FilterNode(PropertyEqualsNode("a", "b"), [FormatLNode("abc")]),
|
||||
]),
|
||||
("-r 3 -f a==b", [
|
||||
FilterNode(TrueNode(), [RecurseDefNode(3)]),
|
||||
FilterNode(PropertyEqualsNode("a", "b"), []),
|
||||
]),
|
||||
("--format_l 'abc' -f a==b", [
|
||||
FilterNode(TrueNode(), [FormatLNode("abc")]),
|
||||
FilterNode(PropertyEqualsNode("a", "b"), []),
|
||||
]),
|
||||
("-f a==b -f c==d", [
|
||||
FilterNode(TrueNode()),
|
||||
FilterNode(PropertyEqualsNode("a", "b")),
|
||||
FilterNode(PropertyEqualsNode("c", "d"))
|
||||
]),
|
||||
("-r 1 -f a==b -r 2 -f c==d -r 3", [
|
||||
FilterNode(TrueNode(), [RecurseDefNode(1)]),
|
||||
FilterNode(PropertyEqualsNode("a", "b"), [RecurseDefNode(2)]),
|
||||
FilterNode(PropertyEqualsNode("c", "d"), [RecurseDefNode(3)])
|
||||
]),
|
||||
])
|
||||
def test_i_can_parse_other_directives(self, text, expected):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
res = parser.parse(context, "explain " + text)
|
||||
parser_result = res.body
|
||||
explanation_node = res.body.body
|
||||
expr_node = explanation_node.expr
|
||||
|
||||
assert res.status
|
||||
assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
|
||||
assert isinstance(explanation_node, ExplanationNode)
|
||||
|
||||
assert expr_node.filters == expected
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("explain -d digest", "digest"),
|
||||
("explain -d", ""),
|
||||
("explain -d -f a=b", "")
|
||||
])
|
||||
def test_i_can_parse_record_digest(self, text, expected):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
res = parser.parse(context, text)
|
||||
explanation_node = res.body.body
|
||||
|
||||
assert explanation_node.digest == expected
|
||||
assert explanation_node.record_digest
|
||||
|
||||
@pytest.mark.parametrize("text, expected_error_type", [
|
||||
("explain digest1 digest2", MultipleDigestError),
|
||||
("explain -r", UnexpectedEof),
|
||||
("explain -r foo", ValueErrorNode),
|
||||
("explain -r 1.2", ValueErrorNode),
|
||||
("explain -f -r 1.2", UnexpectedTokenErrorNode),
|
||||
("explain -f", UnexpectedEof),
|
||||
("explain --format_d", UnexpectedEof),
|
||||
("explain --format_l", UnexpectedEof),
|
||||
("explain --format_l -r foo", UnexpectedTokenErrorNode),
|
||||
("explain --format_d -r foo", UnexpectedTokenErrorNode),
|
||||
])
|
||||
def test_i_cannot_parse(self, text, expected_error_type):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
res = parser.parse(context, text)
|
||||
error = res.body
|
||||
errors = res.body.body
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(error, BuiltinConcepts.ERROR)
|
||||
assert len(errors) == 1
|
||||
assert isinstance(errors[0], expected_error_type)
|
||||
Reference in New Issue
Block a user