Working on #48 : Added BaseExprParser and BaseNodeParser.py

tests/parsers/test_ExpressionParser.py

@@ -3,10 +3,11 @@ import pytest
 from core.builtin_concepts_ids import BuiltinConcepts
 from core.sheerka.services.SheerkaExecute import ParserInput
 from core.tokenizer import Tokenizer
+from parsers.BaseParser import ErrorSink
 from parsers.ExpressionParser import ExpressionParser
 from parsers.expressions import VariableNode
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
-from tests.parsers.parsers_utils import get_expr_node_from_test_node, VAR, EXPR
+from tests.parsers.parsers_utils import get_expr_node_from_test_node, VAR, EXPR, AND
 
 
 class TestExpressionParser(TestUsingMemoryBasedSheerka):
@@ -17,9 +18,10 @@ class TestExpressionParser(TestUsingMemoryBasedSheerka):
 
     def input_parser_with_source(self, source):
         sheerka, context, parser = self.init_parser()
-        parser.reset_parser(context, ParserInput(source))
-        parser.parser_input.next_token()
-        return sheerka, context, parser
+        error_sink = ErrorSink()
+        parser_input = ParserInput(source)
+        parser.reset_parser_input(parser_input, error_sink)
+        return sheerka, context, parser, parser_input, error_sink
 
     def test_i_can_detect_empty_expression(self):
         sheerka, context, parser = self.init_parser()
@@ -29,17 +31,18 @@ class TestExpressionParser(TestUsingMemoryBasedSheerka):
         assert sheerka.isinstance(res.body, BuiltinConcepts.IS_EMPTY)
 
     @pytest.mark.parametrize("expression, expected", [
-        ("var1 + var 2", EXPR("var1 + var 2")),
+        ("var1 + var2", EXPR("var1 + var2")),
         ("variable", VAR("variable")),
         ("var.attr", VAR("var.attr")),
+        ("var1 and var2", AND(VAR("var1"), VAR("var2")))
     ])
     def test_i_can_parse_input(self, expression, expected):
-        sheerka, context, parser = self.input_parser_with_source(expression)
+        sheerka, context, parser, parser_input, error_sink = self.input_parser_with_source(expression)
         expected = get_expr_node_from_test_node(expression, expected)
 
-        parsed = parser.parse_input()
+        parsed = parser.parse_input(context, parser_input, error_sink)
 
-        assert not parser.has_error
+        assert not error_sink.has_error
         assert parsed == expected
 
     @pytest.mark.parametrize("expression", [
@@ -47,10 +50,10 @@ class TestExpressionParser(TestUsingMemoryBasedSheerka):
         "var . attr1 . attr2",
     ])
     def test_i_can_parse_variable(self, expression):
-        sheerka, context, parser = self.input_parser_with_source(expression)
-        parsed = parser.parse_input()
+        sheerka, context, parser, parser_input, error_sink = self.input_parser_with_source(expression)
+        parsed = parser.parse_input(context, parser_input, error_sink)
 
-        assert not parser.has_error
+        assert not error_sink.has_error
         assert isinstance(parsed, VariableNode)
         assert parsed.name == "var"
         assert parsed.attributes == ["attr1", "attr2"]
@@ -60,9 +63,9 @@ class TestExpressionParser(TestUsingMemoryBasedSheerka):
 
         expression = "do not care var1 + var2 do not care either"
         parser_input = ParserInput("text", list(Tokenizer(expression, yield_eof=False)), start=6, end=10)
+        error_sink = ErrorSink()
+        parser.reset_parser_input(parser_input, error_sink)
+        parsed = parser.parse_input(context, parser_input, error_sink)
 
-        parser.reset_parser(context, parser_input)
-        parsed = parser.parse_input()
-
-        assert not parser.has_error
+        assert not error_sink.has_error
         assert parsed == get_expr_node_from_test_node(expression, EXPR("var1 + var2"))