You must now use 'eval' to get the body of a concept

tests/test_DefaultParser.py

@@ -11,49 +11,8 @@ from parsers.DefaultParser import UnexpectedTokenErrorNode, DefConceptNode
 from parsers.BnfParser import BnfParser
 
 
-# def nop():
-#     return NopNode()
-#
-#
-# def n(number):
-#     return NumberNode([], number)
-#
-#
-# def s(string, quote="'"):
-#     return StringNode([], string, quote)
-#
-#
-# def v(name):
-#     return VariableNode([], name)
-#
-#
-# def t():
-#     return TrueNode([])
-#
-#
-# def f():
-#     return FalseNode([])
-#
-#
-# def null():
-#     return NullNode([])
-#
-#
-# def b(operator, left, right):
-#     return BinaryNode([], operator, left, right)
+from sdp.sheerkaDataProvider import Event
 
-#
-# def compare_ast(left, right):
-#     left_as_string = ast.dump(left)
-#     left_as_string = left_as_string.replace(", ctx=Load()", "")
-#     left_as_string = left_as_string.replace(", kind=None", "")
-#
-#     right_as_string = right if isinstance(right, str) else ast.dump(right)
-#     right_as_string = right_as_string.replace(", ctx=Load()", "")
-#     right_as_string = right_as_string.replace(", kind=None", "")
-#
-#     return left_as_string == right_as_string
-#
 
 def get_def_concept(name, where=None, pre=None, post=None, body=None, definition=None):
     def_concept = DefConceptNode([], name=NameNode(list(Tokenizer(name))))
@@ -78,7 +37,7 @@ def get_def_concept(name, where=None, pre=None, post=None, body=None, definition
 def get_context():
     sheerka = Sheerka(skip_builtins_in_db=True)
     sheerka.initialize("mem://")
-    return ExecutionContext("test", "xxx", sheerka)
+    return ExecutionContext("test", Event(), sheerka)
 
 
 def get_concept_part(part):
@@ -104,45 +63,6 @@ def get_concept_part(part):
     if isinstance(part, ReturnValueConcept):
         return part
 
-    # @pytest.mark.parametrize("text, expected", [
-    #     ("1", n(1)),
-    #     ("+1", n(1)),
-    #     ("-1", n(-1)),
-    #     ("'foo'", s("foo")),
-    #     ("identifier", v("identifier")),
-    #     ("true", t()),
-    #     ("false", f()),
-    #     ("null", null()),
-    #     ("1 * 2", b(TokenKind.STAR, n(1), n(2))),
-    #     ("1 * 2/3", b(TokenKind.STAR, n(1), b(TokenKind.SLASH, n(2), n(3)))),
-    #     ("1 + 2", b(TokenKind.PLUS, n(1), n(2))),
-    #     ("1 + 2 - 3", b(TokenKind.PLUS, n(1), b(TokenKind.MINUS, n(2), n(3)))),
-    #     ("1 + 2-3", b(TokenKind.PLUS, n(1), b(TokenKind.PLUS, n(2), n(-3)))),
-    #     ("1 + 2 +-3", b(TokenKind.PLUS, n(1), b(TokenKind.PLUS, n(2), n(-3)))),
-    #     ("1 + 2 * 3", b(TokenKind.PLUS, n(1), b(TokenKind.STAR, n(2), n(3)))),
-    #     ("1 * 2 + 3", b(TokenKind.PLUS, b(TokenKind.STAR, n(1), n(2)), n(3))),
-    #     ("(1 + 2) * 3", b(TokenKind.STAR, b(TokenKind.PLUS, n(1), n(2)), n(3))),
-    #     ("1 * (2 + 3)", b(TokenKind.STAR, n(1), b(TokenKind.PLUS, n(2), n(3)))),
-    # ])
-    # def test_i_can_parse_simple_expression(text, expected):
-    #     parser = DefaultParser(text, None)
-    #     ast = parser.parse()
-    #     assert ast.is_same(expected)
-    #
-    #
-    # @pytest.mark.parametrize("text, token_found, expected_tokens", [
-    #     ("1+", TokenKind.EOF,
-    #      [TokenKind.NUMBER, TokenKind.STRING, TokenKind.IDENTIFIER, 'true', 'false', 'null', TokenKind.LPAR]),
-    #     ("(1+1", TokenKind.EOF, [TokenKind.RPAR])
-    # ])
-    # def test_i_can_detect_unexpected_end_of_code(text, token_found, expected_tokens):
-    #     parser = DefaultParser(text, None)
-    #     parser.parse()
-    #
-    #     assert parser.has_error
-    #     assert parser.error_sink[0].tokens[0].type == token_found
-    #     assert parser.error_sink[0].expected_tokens == expected_tokens
-
 
 @pytest.mark.parametrize("text, expected", [
     ("def concept hello", get_def_concept(name="hello")),