Working on #48 : Working

2021-03-09 09:33:50 +01:00
parent a799ab2bbd
commit 07f0d3670d
6 changed files with 94 additions and 26 deletions
@@ -0,0 +1,114 @@
+import pytest
+
+from core.builtin_concepts_ids import BuiltinConcepts
+from core.sheerka.services.SheerkaExecute import ParserInput
+from core.tokenizer import TokenKind, Tokenizer
+from parsers.RelationalOperatorParser import RelationalOperatorParser
+from parsers.expressions import ParenthesisMismatchError
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+from tests.parsers.parsers_utils import get_expr_node_from_test_node, VAR, EXPR, EQ, NEQ, GT, GTE, LT, LTE, IN, NIN, \
+    PAREN
+
+
+class TestRelationalOperatorParser(TestUsingMemoryBasedSheerka):
+    def init_parser(self):
+        sheerka, context = self.init_concepts()
+        parser = RelationalOperatorParser()
+        return sheerka, context, parser
+
+    def test_i_can_detect_empty_expression(self):
+        sheerka, context, parser = self.init_parser()
+        res = parser.parse(context, ParserInput(""))
+
+        assert not res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.IS_EMPTY)
+
+    @pytest.mark.parametrize("expression, expected", [
+        ("var_name", VAR("var_name")),
+        ("var_name.attr", VAR("var_name.attr")),
+        ("var_name .attr", VAR("var_name.attr", source="var_name .attr")),
+        ("var_name. attr", VAR("var_name.attr", source="var_name. attr")),
+        ("var_name . attr", VAR("var_name.attr", source="var_name . attr")),
+        ("var_name.attr.get_value(x)", VAR("var_name.attr.get_value(x)")),
+        ("var_name.attr == 10", EQ(VAR("var_name.attr"), EXPR("10"))),
+        ("var_name.attr != 10", NEQ(VAR("var_name.attr"), EXPR("10"))),
+        ("var_name.attr > 10", GT(VAR("var_name.attr"), EXPR("10"))),
+        ("var_name.attr >= 10", GTE(VAR("var_name.attr"), EXPR("10"))),
+        ("var_name.attr < 10", LT(VAR("var_name.attr"), EXPR("10"))),
+        ("var_name.attr <= 10", LTE(VAR("var_name.attr"), EXPR("10"))),
+        ("var_name.attr in (a, b)", IN(VAR("var_name.attr"), EXPR("a, b"))),
+        ("var_name.attr not in (a, b)", NIN(VAR("var_name.attr"), EXPR("a, b"))),
+        ("var1.attr1 == var2.attr2", EQ(VAR("var1.attr1"), VAR("var2.attr2"))),
+        ("var1.attr1 == (var2.attr2)", EQ(VAR("var1.attr1"), VAR("var2.attr2"))),
+        ("var_name.attr in (a.b, b.c)", IN(VAR("var_name.attr"), PAREN(EXPR("a.b, b.c"), source="(a.b, b.c)"))),
+
+        ("not a var identifier", EXPR("not a var identifier")),
+        ("func()", EXPR("func()")),
+        ("func(a, not an identifier, x >5)", EXPR("func(a, not an identifier, x >5)")),
+        ("(var_name.attr != var_name2.attr2)", NEQ(VAR("var_name.attr"), VAR("var_name2.attr2")))
+    ])
+    def test_i_can_parse_simple_expressions(self, expression, expected):
+        sheerka, context, parser = self.init_parser()
+        expected = get_expr_node_from_test_node(expression, expected)
+
+        res = parser.parse(context, ParserInput(expression))
+        parser_result = res.body
+        parsed_expr = parser_result.body
+
+        assert res.status
+        assert res.who == parser.name
+        assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
+        assert parsed_expr == expected
+
+    @pytest.mark.parametrize("expression, expected_error, parenthesis_type, index", [
+        ("(", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 0),
+        (")", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 0),
+        ("something (", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 10),
+        ("something )", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 10),
+        ("something == (", BuiltinConcepts.ERROR, TokenKind.LPAR, 13),
+        ("something == )", BuiltinConcepts.ERROR, TokenKind.RPAR, 13),
+        ("something (==", BuiltinConcepts.NOT_FOR_ME, TokenKind.LPAR, 10),
+        ("something )==", BuiltinConcepts.NOT_FOR_ME, TokenKind.RPAR, 10),
+    ])
+    def test_i_can_detect_unbalanced_parenthesis(self, expression, expected_error, parenthesis_type, index):
+        sheerka, context, parser = self.init_parser()
+
+        res = parser.parse(context, ParserInput(expression))
+        assert not res.status
+        if expected_error == BuiltinConcepts.NOT_FOR_ME:
+            assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
+            assert isinstance(res.body.reason[0], ParenthesisMismatchError)
+            assert res.body.reason[0].token.type == parenthesis_type
+            assert res.body.reason[0].token.index == index
+        else:
+            assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
+            assert isinstance(res.body.body[0], ParenthesisMismatchError)
+            assert res.body.body[0].token.type == parenthesis_type
+            assert res.body.body[0].token.index == index
+
+    def test_i_can_detect_syntax_error(self):
+        sheerka, context, parser = self.init_parser()
+
+        expression = "var in a"
+        res = parser.parse(context, ParserInput(expression))
+
+        assert not res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
+        assert isinstance(res.body.body[0], UnexpectedTokenError)
+
+
+
+    def test_i_can_parse_tokens_rather_than_parser_input(self):
+        sheerka, context, parser = self.init_parser()
+        expression = "var1.attr1 == var2.attr2"
+        expected = EQ(VAR("var1.attr1"), VAR("var2.attr2"))
+        expected = get_expr_node_from_test_node(expression, expected)
+
+        res = parser.parse(context, list(Tokenizer(expression)))
+        parser_result = res.body
+        parsed_expr = parser_result.body
+
+        assert res.status
+        assert res.who == parser.name
+        assert sheerka.isinstance(parser_result, BuiltinConcepts.PARSER_RESULT)
+        assert parsed_expr == expected