Implemented some enhancement requests
This commit is contained in:
@@ -851,7 +851,7 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
res = sheerka.inspect(context, 0)
|
||||
|
||||
assert res.body == {'#type#': 'NotFound',
|
||||
'id': '70',
|
||||
'id': sheerka.concepts_ids[BuiltinConcepts.NOT_FOUND],
|
||||
'key': '__NOT_FOUND',
|
||||
'name': '__NOT_FOUND',
|
||||
'body': 'no digest'}
|
||||
@@ -873,7 +873,6 @@ class TestSheerkaDebugManager(TestUsingMemoryBasedSheerka):
|
||||
'#type#': 'ReturnValueConcept',
|
||||
'id': '43',
|
||||
'key': '__RETURN_VALUE',
|
||||
'message': None,
|
||||
'name': '__RETURN_VALUE',
|
||||
'parents': [concept_debug_obj],
|
||||
'status': True,
|
||||
|
||||
@@ -1,233 +0,0 @@
|
||||
from dataclasses import dataclass
|
||||
|
||||
import pytest
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.sheerka.services.SheerkaFilter import Pipe, SheerkaFilter
|
||||
from printer.FormatInstructions import FormatInstructions, FormatDetailDesc, FormatDetailType
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
@dataclass
|
||||
class Obj:
|
||||
prop1: str
|
||||
prop2: str
|
||||
|
||||
|
||||
@dataclass
|
||||
class ObjWithAsBag:
|
||||
prop1: str
|
||||
prop2: object
|
||||
|
||||
def as_bag(self):
|
||||
return {
|
||||
"first_prop": self.prop1,
|
||||
"second_prop": self.prop2,
|
||||
}
|
||||
|
||||
|
||||
class TestSheerkaFilter(TestUsingMemoryBasedSheerka):
|
||||
|
||||
def test_i_can_pipe_using_decorator(self):
|
||||
@Pipe
|
||||
def is_ok_with_decorator(iterable):
|
||||
for item in iterable:
|
||||
yield item + " ok"
|
||||
|
||||
def exclamation(iterable):
|
||||
for item in iterable:
|
||||
yield item + "!"
|
||||
|
||||
res = ["one", "two", "three"] | is_ok_with_decorator | Pipe(exclamation)
|
||||
assert list(res) == ["one ok!", "two ok!", "three ok!"]
|
||||
|
||||
def test_i_can_pipe_function_with_context_as_first_parameter(self):
|
||||
def func_with_context(context, iterable, var_name):
|
||||
for item in iterable:
|
||||
yield f"{context.desc}: {var_name}={item}"
|
||||
|
||||
sheerka, context = self.init_concepts()
|
||||
context.desc = "desc"
|
||||
pipeable = Pipe(func_with_context, context)
|
||||
|
||||
assert pipeable.need_context
|
||||
assert list(["one", "two", "three"] | pipeable("var")) == ['desc: var=one', 'desc: var=two', 'desc: var=three']
|
||||
|
||||
def test_i_can_pipe_function_with_context_as_only_parameter(self):
|
||||
# This time, func_with_context does not have other parameter than context and iterable
|
||||
def func_with_context(context, iterable):
|
||||
for item in iterable:
|
||||
yield f"{context.desc}: var={item}"
|
||||
|
||||
sheerka, context = self.init_concepts()
|
||||
context.desc = "desc"
|
||||
pipeable = Pipe(func_with_context, context)
|
||||
|
||||
assert pipeable.need_context
|
||||
assert list(["one", "two", "three"] | pipeable) == ['desc: var=one', 'desc: var=two', 'desc: var=three']
|
||||
|
||||
def test_i_can_pipe_explanation_concept(self):
|
||||
sheerka, context = self.init_concepts()
|
||||
execution_contexts = [context.push(BuiltinConcepts.NOP, None, desc=f"desc_{i}") for i in range(4)]
|
||||
explanation_node = sheerka.new(BuiltinConcepts.EXPLANATION, body=execution_contexts)
|
||||
|
||||
@Pipe
|
||||
def get_desc(iterable):
|
||||
for item in iterable:
|
||||
yield item.desc
|
||||
|
||||
res = explanation_node | get_desc
|
||||
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.EXPLANATION)
|
||||
assert list(res.body) == ["desc_0", "desc_1", "desc_2", "desc_3"] # body is modified
|
||||
|
||||
@pytest.mark.parametrize("predicate, expected", [
|
||||
("True", ["one", "two", "three"]),
|
||||
("self == 'two'", ["two"])
|
||||
])
|
||||
def test_i_can_filter(self, predicate, expected):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
res = ["one", "two", "three"] | Pipe(filter_service.pipe_filter)(predicate)
|
||||
|
||||
assert list(res) == expected
|
||||
|
||||
def test_i_can_filter_obj(self):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
lst = [Obj("a", "b"), Obj("c", "d")]
|
||||
predicate = "prop2 == 'd'"
|
||||
res = lst | Pipe(filter_service.pipe_filter)(predicate)
|
||||
|
||||
assert list(res) == [Obj("c", "d")]
|
||||
|
||||
def test_i_can_filter_obj_implementing_as_bag(self):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
lst = [ObjWithAsBag("a", "b"), ObjWithAsBag("c", "d")]
|
||||
predicate = "second_prop == 'd'"
|
||||
res = lst | Pipe(filter_service.pipe_filter)(predicate)
|
||||
|
||||
assert list(res) == [ObjWithAsBag("c", "d")]
|
||||
|
||||
def test_i_can_manage_name_error(self):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
lst = [Obj("a", "b"), Obj("c", "d"), ObjWithAsBag("a", "b"), ObjWithAsBag("c", "d")]
|
||||
predicate = "second_prop == 'd'" # 'second_prop' does not exist in Obj
|
||||
res = lst | Pipe(filter_service.pipe_filter)(predicate)
|
||||
|
||||
assert list(res) == [ObjWithAsBag("c", "d")]
|
||||
|
||||
def test_i_cannot_filter_if_the_predicate_is_incorrect(self):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
lst = [Obj("a", "b"), Obj("c", "d")]
|
||||
predicate = "prop2 =="
|
||||
|
||||
with pytest.raises(SyntaxError):
|
||||
res = lst | Pipe(filter_service.pipe_filter)(predicate)
|
||||
list(res)
|
||||
|
||||
def test_i_can_format_l(self):
|
||||
sheerka, context, foo, bar = self.init_concepts("foo", "bar")
|
||||
lst = [foo, bar]
|
||||
|
||||
res = lst | Pipe(SheerkaFilter.pipe_format_l)("my_format")
|
||||
res = list(res)
|
||||
|
||||
assert len(res) == 2
|
||||
format_instructions = res[0].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.format_l[f"c:{foo.id}:"] == "my_format"
|
||||
|
||||
format_instructions = res[1].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.format_l[f"c:{bar.id}:"] == "my_format"
|
||||
|
||||
def test_i_can_format_d(self):
|
||||
sheerka, context, foo, bar = self.init_concepts("foo", "bar")
|
||||
lst = [foo, bar]
|
||||
|
||||
res = lst | Pipe(SheerkaFilter.pipe_format_d)("id", "name", "body", id="%red%{id}%reset%")
|
||||
res = list(res)
|
||||
|
||||
expected_props = {
|
||||
"id": "%red%{id}%reset%",
|
||||
"name": "{name}",
|
||||
"body": "{body}"
|
||||
}
|
||||
|
||||
assert len(res) == 2
|
||||
format_instructions = res[0].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.format_d[f"c:{foo.id}:"] == FormatDetailDesc(FormatDetailType.Props_In_Line, expected_props)
|
||||
|
||||
format_instructions = res[1].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.format_d[f"c:{bar.id}:"] == FormatDetailDesc(FormatDetailType.Props_In_Line, expected_props)
|
||||
|
||||
def test_i_can_format_d_all_properties(self):
|
||||
sheerka, context, foo, bar = self.init_concepts("foo", "bar")
|
||||
lst = [foo, bar]
|
||||
|
||||
res = lst | Pipe(SheerkaFilter.pipe_format_d)()
|
||||
res = list(res)
|
||||
|
||||
expected_props = {
|
||||
'id': '{id}',
|
||||
'name': '{name}',
|
||||
'key': '{key}',
|
||||
'body': '{body}',
|
||||
'self': '{self}'
|
||||
}
|
||||
|
||||
assert len(res) == 2
|
||||
format_instructions = res[0].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.format_d[f"c:{foo.id}:"] == FormatDetailDesc(FormatDetailType.Props_In_Line, expected_props)
|
||||
|
||||
def test_i_can_set_recurse(self):
|
||||
sheerka, context, foo, bar = self.init_concepts("foo", "bar")
|
||||
lst = [foo, bar]
|
||||
|
||||
res = lst | Pipe(SheerkaFilter.pipe_recurse)(10)
|
||||
res = list(res)
|
||||
|
||||
assert len(res) == 2
|
||||
format_instructions = res[0].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.recursive_props["_children"] == 10
|
||||
|
||||
format_instructions = res[1].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.recursive_props["_children"] == 10
|
||||
|
||||
res = lst | Pipe(SheerkaFilter.pipe_recurse)(15, "other_prop")
|
||||
res = list(res)
|
||||
|
||||
assert len(res) == 2
|
||||
format_instructions = res[0].get_prop(BuiltinConcepts.FORMAT_INSTRUCTIONS)
|
||||
assert isinstance(format_instructions, FormatInstructions)
|
||||
assert format_instructions.recursive_props["_children"] == 10
|
||||
assert format_instructions.recursive_props["other_prop"] == 15
|
||||
|
||||
def test_i_can_inspect_obj(self):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
lst = [Obj("a", "b"), Obj("c", "d")]
|
||||
res = lst | Pipe(filter_service.pipe_inspect)("prop2")
|
||||
|
||||
assert list(res) == ["b", "d"]
|
||||
|
||||
def test_i_can_inspect_obj_with_bag(self):
|
||||
filter_service = SheerkaFilter(None)
|
||||
|
||||
lst = [ObjWithAsBag("a", "b"), ObjWithAsBag("c", "d")]
|
||||
res = lst | Pipe(filter_service.pipe_inspect)("second_prop")
|
||||
|
||||
assert list(res) == ["b", "d"]
|
||||
|
||||
lst = [ObjWithAsBag("a", ObjWithAsBag("b", ObjWithAsBag("c", "d")))]
|
||||
res = lst | Pipe(filter_service.pipe_inspect)("second_prop.second_prop.second_prop")
|
||||
assert list(res) == ["d"]
|
||||
@@ -86,14 +86,13 @@ class TestSheerkaUsingMemoryBasedSheerka(TestUsingMemoryBasedSheerka):
|
||||
|
||||
def test_i_can_instantiate_a_builtin_concept_when_it_has_its_own_class(self):
|
||||
sheerka = self.get_sheerka()
|
||||
ret = sheerka.new(BuiltinConcepts.RETURN_VALUE, who="who", status="status", value="value", message="message")
|
||||
ret = sheerka.new(BuiltinConcepts.RETURN_VALUE, who="who", status="status", value="value")
|
||||
|
||||
assert isinstance(ret, ReturnValueConcept)
|
||||
assert ret.key == str(BuiltinConcepts.RETURN_VALUE)
|
||||
assert ret.who == "who"
|
||||
assert ret.status == "status"
|
||||
assert ret.value == "value"
|
||||
assert ret.message == "message"
|
||||
|
||||
# check the others
|
||||
for key, concept_class in sheerka.get_builtins_classes_as_dict().items():
|
||||
|
||||
@@ -3,7 +3,6 @@ from dataclasses import dataclass
|
||||
import pytest
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.concept import Concept, ConceptParts
|
||||
from core.sheerka.services.SheerkaFilter import Pipe, SheerkaFilter
|
||||
from printer.Formatter import Formatter, BraceToken
|
||||
from printer.SheerkaPrinter import FormatInstructions
|
||||
|
||||
@@ -446,16 +445,6 @@ bar: *name 'bar' is not defined*
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == expected
|
||||
|
||||
def test_i_can_manage_exception_when_printing(self, capsys):
|
||||
sheerka = self.get_sheerka()
|
||||
filter_service = SheerkaFilter(sheerka)
|
||||
predicate = "self='two'" # it should be self=='two'
|
||||
items = ["one", "two", "three"] | Pipe(filter_service.pipe_filter)(predicate)
|
||||
|
||||
sheerka.print(items)
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == "\x1b[31mSyntaxError: invalid syntax\nself='two'\n ^\x1b[0m\n"
|
||||
|
||||
@pytest.mark.parametrize("template, expected", [
|
||||
(None, []),
|
||||
("", []),
|
||||
|
||||
@@ -61,6 +61,7 @@ def python_ret_val(source):
|
||||
python_node = PythonNode(source, ast.parse(source, f"<source>", 'eval'))
|
||||
return pr_ret_val(python_node, parser="Python", source=source)
|
||||
|
||||
|
||||
def new_concept(key, **kwargs):
|
||||
res = Concept(key=key, name=key, is_builtin=False, is_unique=False)
|
||||
for k, v in kwargs.items():
|
||||
|
||||
@@ -4,7 +4,7 @@ from core.rule import Rule, RuleMetadata
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import Tokenizer
|
||||
from evaluators.FormatRuleEvaluator import FormatRuleEvaluator
|
||||
from parsers.FormatRuleParser import FormatRuleNode, FormatRuleParser
|
||||
from parsers.DefFormatRuleParser import FormatRuleNode, DefFormatRuleParser
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -33,7 +33,7 @@ class TestFormatRuleEvaluator(TestUsingMemoryBasedSheerka):
|
||||
def test_i_can_eval(self):
|
||||
sheerka, context = self.init_concepts()
|
||||
text = "when isinstance(value, __EXPLANATION) print list(value)"
|
||||
ret_val = FormatRuleParser().parse(context, ParserInput(text))
|
||||
ret_val = DefFormatRuleParser().parse(context, ParserInput(text))
|
||||
|
||||
res = FormatRuleEvaluator().eval(context, ret_val)
|
||||
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
import pytest
|
||||
from core.builtin_concepts_ids import BuiltinConcepts
|
||||
from evaluators.MultipleSuccessEvaluator import MultipleSuccessEvaluator
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
from tests.evaluators.EvaluatorTestsUtils import p_ret_val_true, reduced_requested, e_ret_val_new, p_ret_val_false, \
|
||||
e_ret_val_false, ret_val
|
||||
|
||||
|
||||
class TestMultipleSuccessEvaluator(TestUsingMemoryBasedSheerka):
|
||||
|
||||
@pytest.mark.parametrize("return_values, expected", [
|
||||
([p_ret_val_true()], False), # all remaining parsers must be in error
|
||||
|
||||
([e_ret_val_false()], False), # all remaining evaluators must be successful
|
||||
|
||||
([e_ret_val_new("foo"),
|
||||
e_ret_val_new("foo")], False), # same returns values
|
||||
|
||||
([e_ret_val_new("foo", body=1),
|
||||
e_ret_val_new("foo", body=1)], False), # same returns values
|
||||
|
||||
([reduced_requested,
|
||||
e_ret_val_new("foo"),
|
||||
e_ret_val_new("bar"),
|
||||
p_ret_val_false("value")], True),
|
||||
])
|
||||
def test_i_can_match(self, return_values, expected):
|
||||
sheerka, context = self.init_concepts()
|
||||
evaluator = MultipleSuccessEvaluator()
|
||||
|
||||
assert evaluator.matches(context, return_values) == expected
|
||||
|
||||
def test_i_can_eval(self):
|
||||
sheerka, context = self.init_concepts()
|
||||
evaluator = MultipleSuccessEvaluator()
|
||||
|
||||
ret1 = e_ret_val_new("foo")
|
||||
ret2 = e_ret_val_new("bar")
|
||||
parser_in_error = p_ret_val_false("value")
|
||||
return_values = [reduced_requested,
|
||||
ret1,
|
||||
ret2,
|
||||
parser_in_error,
|
||||
ret_val("success value not coming from evaluator")]
|
||||
|
||||
assert evaluator.matches(context, return_values)
|
||||
|
||||
res = evaluator.eval(context, return_values)
|
||||
|
||||
assert sheerka.isinstance(res, BuiltinConcepts.RETURN_VALUE)
|
||||
assert res.who == evaluator.name
|
||||
assert res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.MULTIPLE_SUCCESS)
|
||||
assert res.body.body == [ret1, ret2]
|
||||
assert res.parents == [reduced_requested, ret1, ret2, parser_in_error]
|
||||
@@ -2,6 +2,11 @@ from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
|
||||
class TestSheerkaNonRegDisplay(TestUsingMemoryBasedSheerka):
|
||||
@classmethod
|
||||
def teardown_class(cls):
|
||||
# At the end of the tests, sheerka singleton instance will be corrupted
|
||||
# Ask for a new one
|
||||
TestSheerkaNonRegDisplay.singleton_instance = None
|
||||
|
||||
def test_i_can_display_results_when_return_values_processing_is_on(self, capsys):
|
||||
init = [
|
||||
@@ -51,4 +56,20 @@ post : None
|
||||
ret : None
|
||||
vars : []
|
||||
props : {}
|
||||
"""
|
||||
|
||||
def test_i_can_display_multiple_success(self, capsys):
|
||||
init = [
|
||||
"def concept foo as 1",
|
||||
"def concept foo as 2",
|
||||
]
|
||||
sheerka = self.init_scenario(init)
|
||||
capsys.readouterr()
|
||||
|
||||
sheerka.enable_process_return_values = True
|
||||
sheerka.evaluate_user_input("foo")
|
||||
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == """ReturnValue(who=evaluators.Concept, status=True, value=(1001)foo)
|
||||
ReturnValue(who=evaluators.Concept, status=True, value=(1002)foo)
|
||||
"""
|
||||
|
||||
@@ -332,7 +332,7 @@ class TestSheerkaOut(TestUsingMemoryBasedSheerka):
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == """foo: (1001)foo
|
||||
bar: (1002)bar
|
||||
ReturnValue(who=Test, status=True, value=(1003)baz, message=None)
|
||||
ReturnValue(who=Test, status=True, value=(1003)baz)
|
||||
"""
|
||||
|
||||
def test_i_can_print_out_a_list_with_recurse(self, capsys):
|
||||
@@ -351,11 +351,11 @@ ReturnValue(who=Test, status=True, value=(1003)baz, message=None)
|
||||
|
||||
service.process_return_values(context, rets)
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == """ReturnValue(who=Test, status=True, value=r1, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r11, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r111, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r2, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r22, message=None)
|
||||
assert captured.out == """ReturnValue(who=Test, status=True, value=r1)
|
||||
ReturnValue(who=Test, status=True, value=r11)
|
||||
ReturnValue(who=Test, status=True, value=r111)
|
||||
ReturnValue(who=Test, status=True, value=r2)
|
||||
ReturnValue(who=Test, status=True, value=r22)
|
||||
"""
|
||||
|
||||
def test_i_can_print_out_a_list_with_recurse_using_format_instr(self, capsys):
|
||||
@@ -376,11 +376,11 @@ ReturnValue(who=Test, status=True, value=r2, message=None)
|
||||
|
||||
service.process_return_values(context, rets)
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == """ReturnValue(who=Test, status=True, value=r1, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r11, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r111, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r2, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r22, message=None)
|
||||
assert captured.out == """ReturnValue(who=Test, status=True, value=r1)
|
||||
ReturnValue(who=Test, status=True, value=r11)
|
||||
ReturnValue(who=Test, status=True, value=r111)
|
||||
ReturnValue(who=Test, status=True, value=r2)
|
||||
ReturnValue(who=Test, status=True, value=r22)
|
||||
"""
|
||||
|
||||
def test_i_can_print_out_a_list_with_recurse_using_container_format_instr(self, capsys):
|
||||
@@ -400,11 +400,11 @@ ReturnValue(who=Test, status=True, value=r2, message=None)
|
||||
|
||||
service.process_return_values(context, foo)
|
||||
captured = capsys.readouterr()
|
||||
assert captured.out == """ReturnValue(who=Test, status=True, value=r1, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r11, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r111, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r2, message=None)
|
||||
ReturnValue(who=Test, status=True, value=r22, message=None)
|
||||
assert captured.out == """ReturnValue(who=Test, status=True, value=r1)
|
||||
ReturnValue(who=Test, status=True, value=r11)
|
||||
ReturnValue(who=Test, status=True, value=r111)
|
||||
ReturnValue(who=Test, status=True, value=r2)
|
||||
ReturnValue(who=Test, status=True, value=r22)
|
||||
"""
|
||||
|
||||
def test_i_can_print_out_color(self, capsys):
|
||||
|
||||
@@ -2,7 +2,7 @@ import pytest
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import Keywords, Tokenizer, TokenKind
|
||||
from parsers.BaseCustomGrammarParser import BaseCustomGrammarParser, SyntaxErrorNode, KeywordNotFound
|
||||
from parsers.BaseParser import UnexpectedEofNode, UnexpectedTokenErrorNode
|
||||
from parsers.BaseParser import UnexpectedEofParsingError, UnexpectedTokenParsingError
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -83,9 +83,9 @@ func(a)
|
||||
sheerka, context, parser = self.init_parser("when xxx print yyy")
|
||||
|
||||
assert parser.get_parts(["when", "print"], Keywords.PRINT) is None
|
||||
assert parser.error_sink == [UnexpectedTokenErrorNode(f"'print' keyword not found.",
|
||||
assert parser.error_sink == [UnexpectedTokenParsingError(f"'print' keyword not found.",
|
||||
"when",
|
||||
[Keywords.PRINT])]
|
||||
[Keywords.PRINT])]
|
||||
|
||||
def test_i_can_detect_when_a_keyword_appears_several_times(self):
|
||||
sheerka, context, parser = self.init_parser("print hello when True print True")
|
||||
@@ -106,7 +106,7 @@ func(a)
|
||||
|
||||
assert parser.get_parts(["print", "when"]) is not None
|
||||
assert len(parser.error_sink) == 1
|
||||
assert isinstance(parser.error_sink[0], UnexpectedEofNode)
|
||||
assert isinstance(parser.error_sink[0], UnexpectedEofParsingError)
|
||||
assert parser.error_sink[0].message == "While parsing keyword 'print'."
|
||||
|
||||
def test_i_can_double_quoted_strings_are_expanded(self):
|
||||
@@ -178,7 +178,7 @@ print xxx"""
|
||||
sheerka, context, parser = self.init_parser(text)
|
||||
|
||||
assert parser.get_parts(["when"])
|
||||
assert parser.error_sink == [UnexpectedTokenErrorNode("Indentation not found.", "x", [TokenKind.WHITESPACE])]
|
||||
assert parser.error_sink == [UnexpectedTokenParsingError("Indentation not found.", "x", [TokenKind.WHITESPACE])]
|
||||
|
||||
@pytest.mark.parametrize("text", [
|
||||
"",
|
||||
@@ -197,7 +197,7 @@ print xxx"""
|
||||
sheerka, context, parser = self.init_parser("")
|
||||
|
||||
assert parser.get_body(list(Tokenizer("not a newline", yield_eof=False))) is None
|
||||
assert parser.error_sink == [UnexpectedTokenErrorNode("New line not found.", "not", [TokenKind.NEWLINE])]
|
||||
assert parser.error_sink == [UnexpectedTokenParsingError("New line not found.", "not", [TokenKind.NEWLINE])]
|
||||
|
||||
@pytest.mark.parametrize("text", [
|
||||
"\nx x",
|
||||
@@ -207,14 +207,14 @@ print xxx"""
|
||||
sheerka, context, parser = self.init_parser("")
|
||||
|
||||
assert parser.get_body(list(Tokenizer(text, yield_eof=False))) is None
|
||||
assert parser.error_sink == [UnexpectedTokenErrorNode("Indentation not found.", "x", [TokenKind.WHITESPACE])]
|
||||
assert parser.error_sink == [UnexpectedTokenParsingError("Indentation not found.", "x", [TokenKind.WHITESPACE])]
|
||||
|
||||
def test_i_can_detect_missing_tab_when_get_body(self):
|
||||
text = "\n\txxx\n\tyyy\nzzz"
|
||||
|
||||
sheerka, context, parser = self.init_parser("")
|
||||
assert parser.get_body(list(Tokenizer(text, yield_eof=False))) is None
|
||||
assert parser.error_sink == [UnexpectedTokenErrorNode("Indentation not found.", "zzz", [TokenKind.WHITESPACE])]
|
||||
assert parser.error_sink == [UnexpectedTokenParsingError("Indentation not found.", "zzz", [TokenKind.WHITESPACE])]
|
||||
|
||||
def test_i_can_detect_invalid_indentation_when_get_body(self):
|
||||
sheerka, context, parser = self.init_parser("")
|
||||
|
||||
@@ -1,50 +1,7 @@
|
||||
import pytest
|
||||
|
||||
from core.tokenizer import Tokenizer, TokenKind, Token
|
||||
from parsers.BaseParser import BaseParser, BaseSplitIterParser
|
||||
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("", ["<eof>"]),
|
||||
("one two -f --file", ["one", "two", "-f", "--file", "<eof>"]),
|
||||
("one 'two three'", ["one", "two three", "<eof>"]),
|
||||
('one "two three"', ["one", "two three", "<eof>"]),
|
||||
('one\\ two three"', ["one two", "three", "<eof>"]),
|
||||
("one 'two\\' three'", ["one", "two' three", "<eof>"]),
|
||||
("one\\\\two three", ["one\\two", "three", "<eof>"]),
|
||||
("one\ntwo three", ["one", "two", "three", "<eof>"]),
|
||||
("one \n two three", ["one", "two", "three", "<eof>"]),
|
||||
("'one \n two' three", ["one \n two", "three", "<eof>"]),
|
||||
("a=b", ["a", "=", "b", "<eof>"]),
|
||||
("a = b", ["a", "=", "b", "<eof>"]),
|
||||
("a==b", ["a", "==", "b", "<eof>"]),
|
||||
("a == b", ["a", "==", "b", "<eof>"]),
|
||||
])
|
||||
def test_i_can_split_using_base_split_iterparser_class(text, expected):
|
||||
parser = BaseSplitIterParser("BaseSplitIterParser", 0)
|
||||
parser.reset_parser(None, text)
|
||||
res = [t.value for t in parser.split()]
|
||||
|
||||
assert res == expected
|
||||
|
||||
|
||||
def test_i_can_test_split_iter_parser_indexes():
|
||||
parser = BaseSplitIterParser("BaseSplitIterParser", 0)
|
||||
text = "one two \n three = ==(),"
|
||||
parser.reset_parser(None, text)
|
||||
res = []
|
||||
while parser.next_token():
|
||||
res.append(parser.get_token())
|
||||
|
||||
assert res[0] == Token(TokenKind.WORD, "one", 0, 1, 1)
|
||||
assert res[1] == Token(TokenKind.WORD, "two", 4, 1, 5)
|
||||
assert res[2] == Token(TokenKind.WORD, "three", 10, 2, 2)
|
||||
assert res[3] == Token(TokenKind.EQUALS, "=", 16, 2, 8)
|
||||
assert res[4] == Token(TokenKind.EQUALSEQUALS, "==", 18, 2, 10)
|
||||
assert res[5] == Token(TokenKind.LPAR, "(", 20, 2, 12)
|
||||
assert res[6] == Token(TokenKind.RPAR, ")", 21, 2, 13)
|
||||
assert res[7] == Token(TokenKind.COMMA, ",", 22, 2, 14)
|
||||
from core.tokenizer import Tokenizer
|
||||
from parsers.BaseParser import BaseParser
|
||||
|
||||
|
||||
@pytest.mark.parametrize("tokens, expected", [
|
||||
@@ -61,4 +18,3 @@ def test_i_can_test_split_iter_parser_indexes():
|
||||
])
|
||||
def test_i_can_get_tokens_boundaries(tokens, expected):
|
||||
assert BaseParser.get_tokens_boundaries(tokens) == expected
|
||||
|
||||
|
||||
@@ -4,8 +4,8 @@ from core.concept import Concept, DEFINITION_TYPE_BNF
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import Tokenizer, TokenKind, LexerError
|
||||
from parsers.BaseNodeParser import cnode
|
||||
from parsers.BaseParser import UnexpectedTokenErrorNode
|
||||
from parsers.BnfDefinitionParser import BnfDefinitionParser, UnexpectedEndOfFileError
|
||||
from parsers.BaseParser import UnexpectedTokenParsingError, UnexpectedEofParsingError
|
||||
from parsers.BnfDefinitionParser import BnfDefinitionParser
|
||||
from parsers.BnfNodeParser import BnfNodeParser
|
||||
from parsers.BnfNodeParser import StrMatch, Optional, ZeroOrMore, OrderedChoice, Sequence, \
|
||||
OneOrMore, ConceptExpression
|
||||
@@ -147,10 +147,10 @@ class TestBnfParser(TestUsingMemoryBasedSheerka):
|
||||
assert res.value.source == expression
|
||||
|
||||
@pytest.mark.parametrize("expression, error", [
|
||||
("1 ", UnexpectedEndOfFileError()),
|
||||
("1|", UnexpectedEndOfFileError()),
|
||||
("(1|)", UnexpectedTokenErrorNode("Unexpected token 'Token(<EOF>)'", eof_token, [TokenKind.RPAR])),
|
||||
("1=", UnexpectedTokenErrorNode("Unexpected token 'Token(<EOF>)'", eof_token, [TokenKind.IDENTIFIER])),
|
||||
("1 ", UnexpectedEofParsingError()),
|
||||
("1|", UnexpectedEofParsingError()),
|
||||
("(1|)", UnexpectedTokenParsingError("Unexpected token 'Token(<EOF>)'", eof_token, [TokenKind.RPAR])),
|
||||
("1=", UnexpectedTokenParsingError("Unexpected token 'Token(<EOF>)'", eof_token, [TokenKind.IDENTIFIER])),
|
||||
])
|
||||
def test_i_can_detect_errors(self, expression, error):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
@@ -7,11 +7,11 @@ from core.concept import DEFINITION_TYPE_BNF, DEFINITION_TYPE_DEF, Concept, CV
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import Keywords, Tokenizer, LexerError
|
||||
from parsers.BaseNodeParser import SCWC
|
||||
from parsers.BaseParser import NotInitializedNode, UnexpectedEofNode
|
||||
from parsers.BaseParser import NotInitializedNode, UnexpectedEofParsingError
|
||||
from parsers.BnfNodeParser import OrderedChoice, ConceptExpression, StrMatch, Sequence
|
||||
from parsers.BnfDefinitionParser import BnfDefinitionParser
|
||||
from parsers.DefConceptParser import DefConceptParser, NameNode, SyntaxErrorNode
|
||||
from parsers.DefConceptParser import UnexpectedTokenErrorNode, DefConceptNode
|
||||
from parsers.DefConceptParser import UnexpectedTokenParsingError, DefConceptNode
|
||||
from parsers.FunctionParser import FunctionParser
|
||||
from parsers.PythonParser import PythonParser, PythonNode
|
||||
|
||||
@@ -119,9 +119,9 @@ class TestDefConceptParser(TestUsingMemoryBasedSheerka):
|
||||
return sheerka, context, parser, *updated
|
||||
|
||||
@pytest.mark.parametrize("text, error", [
|
||||
("concept", UnexpectedTokenErrorNode("'def' keyword not found.", "concept", [Keywords.DEF])),
|
||||
("hello word", UnexpectedTokenErrorNode("'def' keyword not found.", "hello", [Keywords.DEF])),
|
||||
("def hello", UnexpectedTokenErrorNode("'concept' keyword not found.", "hello", [Keywords.CONCEPT])),
|
||||
("concept", UnexpectedTokenParsingError("'def' keyword not found.", "concept", [Keywords.DEF])),
|
||||
("hello word", UnexpectedTokenParsingError("'def' keyword not found.", "hello", [Keywords.DEF])),
|
||||
("def hello", UnexpectedTokenParsingError("'concept' keyword not found.", "hello", [Keywords.CONCEPT])),
|
||||
])
|
||||
def test_i_can_detect_not_for_me(self, text, error):
|
||||
sheerka, context, parser, *concepts = self.init_parser()
|
||||
@@ -196,7 +196,7 @@ class TestDefConceptParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(return_value, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert isinstance(return_value.reason[0], UnexpectedTokenErrorNode)
|
||||
assert isinstance(return_value.reason[0], UnexpectedTokenParsingError)
|
||||
assert return_value.reason[0].message == "'concept' keyword not found."
|
||||
assert return_value.reason[0].expected_tokens == [Keywords.CONCEPT]
|
||||
assert return_value.reason[0].token.value == "hello"
|
||||
@@ -381,8 +381,8 @@ def concept add one to a as:
|
||||
("def concept name from def", SyntaxErrorNode([], "Empty 'from' declaration.")),
|
||||
("def concept name from def ", SyntaxErrorNode([], "Empty 'from' declaration.")),
|
||||
("def concept name from as True", SyntaxErrorNode([], "Empty 'from' declaration.")),
|
||||
("def concept name from", UnexpectedEofNode("While parsing keyword 'from'.")),
|
||||
("def concept name from ", UnexpectedEofNode("While parsing keyword 'from'.")),
|
||||
("def concept name from", UnexpectedEofParsingError("While parsing keyword 'from'.")),
|
||||
("def concept name from ", UnexpectedEofParsingError("While parsing keyword 'from'.")),
|
||||
])
|
||||
def test_i_can_detect_empty_def_declaration(self, text, error):
|
||||
sheerka, context, parser, *concepts = self.init_parser()
|
||||
@@ -474,7 +474,7 @@ from give me the date !
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert isinstance(res.body.reason[0], UnexpectedTokenErrorNode)
|
||||
assert isinstance(res.body.reason[0], UnexpectedTokenParsingError)
|
||||
|
||||
@pytest.mark.parametrize("text, error_msg, error_text", [
|
||||
("'name", "Missing Trailing quote", "'name"),
|
||||
|
||||
@@ -5,7 +5,7 @@ from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.sheerka.services.SheerkaRuleManager import FormatAstRawText, RulePredicate, FormatAstVariable
|
||||
from core.tokenizer import Keywords, Tokenizer
|
||||
from parsers.BaseCustomGrammarParser import KeywordNotFound
|
||||
from parsers.FormatRuleParser import FormatRuleParser, FormatRuleNode
|
||||
from parsers.DefFormatRuleParser import DefFormatRuleParser, FormatRuleNode
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -17,7 +17,7 @@ cmap = {
|
||||
}
|
||||
|
||||
|
||||
class TestFormatRuleParser(TestUsingMemoryBasedSheerka):
|
||||
class TestDefFormatRuleParser(TestUsingMemoryBasedSheerka):
|
||||
sheerka = None
|
||||
|
||||
@classmethod
|
||||
@@ -29,10 +29,10 @@ class TestFormatRuleParser(TestUsingMemoryBasedSheerka):
|
||||
if concepts_map is not None:
|
||||
sheerka, context, *concepts = self.init_concepts(*concepts_map.values(), create_new=True)
|
||||
else:
|
||||
sheerka = TestFormatRuleParser.sheerka
|
||||
sheerka = TestDefFormatRuleParser.sheerka
|
||||
context = self.get_context(sheerka)
|
||||
|
||||
parser = FormatRuleParser()
|
||||
parser = DefFormatRuleParser()
|
||||
return sheerka, context, parser
|
||||
|
||||
def test_i_can_detect_empty_expression(self):
|
||||
@@ -5,7 +5,7 @@ from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
|
||||
from core.concept import Concept
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import Tokenizer, TokenKind
|
||||
from parsers.BaseParser import UnexpectedEofNode, UnexpectedTokenErrorNode
|
||||
from parsers.BaseParser import UnexpectedEofParsingError, UnexpectedTokenParsingError
|
||||
from parsers.ExpressionParser import PropertyEqualsNode, PropertyEqualsSequenceNode, PropertyContainsNode, AndNode, \
|
||||
OrNode, NotNode, LambdaNode, IsaNode, NameExprNode, ExpressionParser, LeftPartNotFoundError, TrueifyVisitor
|
||||
|
||||
@@ -54,12 +54,12 @@ class TestExpressionParser(TestUsingMemoryBasedSheerka):
|
||||
assert expressions == expected
|
||||
|
||||
@pytest.mark.parametrize("expression, expected_errors", [
|
||||
("one or", [UnexpectedEofNode("When parsing 'or'")]),
|
||||
("one and", [UnexpectedEofNode("When parsing 'and'")]),
|
||||
("one or", [UnexpectedEofParsingError("When parsing 'or'")]),
|
||||
("one and", [UnexpectedEofParsingError("When parsing 'and'")]),
|
||||
("and one", [LeftPartNotFoundError()]),
|
||||
("or one", [LeftPartNotFoundError()]),
|
||||
("or", [LeftPartNotFoundError(), UnexpectedEofNode("When parsing 'or'")]),
|
||||
("and", [LeftPartNotFoundError(), UnexpectedEofNode("When parsing 'and'")]),
|
||||
("or", [LeftPartNotFoundError(), UnexpectedEofParsingError("When parsing 'or'")]),
|
||||
("and", [LeftPartNotFoundError(), UnexpectedEofParsingError("When parsing 'and'")]),
|
||||
])
|
||||
def test_i_can_detect_error(self, expression, expected_errors):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
@@ -75,28 +75,28 @@ class TestExpressionParser(TestUsingMemoryBasedSheerka):
|
||||
res = parser.parse(context, ParserInput("("))
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert isinstance(res.body.reason[0], UnexpectedTokenErrorNode)
|
||||
assert isinstance(res.body.reason[0], UnexpectedTokenParsingError)
|
||||
assert res.body.reason[0].token.type == TokenKind.EOF
|
||||
assert res.body.reason[0].expected_tokens == [TokenKind.RPAR]
|
||||
|
||||
res = parser.parse(context, ParserInput(")"))
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert isinstance(res.body.reason[0], UnexpectedTokenErrorNode)
|
||||
assert isinstance(res.body.reason[0], UnexpectedTokenParsingError)
|
||||
assert res.body.reason[0].token.type == TokenKind.RPAR
|
||||
assert res.body.reason[0].expected_tokens == []
|
||||
|
||||
res = parser.parse(context, ParserInput("one and two)"))
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
|
||||
assert isinstance(res.body.body[0], UnexpectedTokenErrorNode)
|
||||
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
|
||||
assert res.body.body[0].token.type == TokenKind.RPAR
|
||||
assert res.body.body[0].expected_tokens == []
|
||||
|
||||
res = parser.parse(context, ParserInput("one and two)"))
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.body, BuiltinConcepts.ERROR)
|
||||
assert isinstance(res.body.body[0], UnexpectedTokenErrorNode)
|
||||
assert isinstance(res.body.body[0], UnexpectedTokenParsingError)
|
||||
assert res.body.body[0].token.type == TokenKind.RPAR
|
||||
assert res.body.body[0].expected_tokens == []
|
||||
|
||||
|
||||
@@ -5,7 +5,7 @@ import pytest
|
||||
from core.builtin_concepts import ParserResultConcept, NotForMeConcept, BuiltinConcepts
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from core.tokenizer import LexerError, TokenKind
|
||||
from parsers.PythonParser import PythonNode, PythonParser, PythonErrorNode, ConceptDetected
|
||||
from parsers.PythonParser import PythonNode, PythonParser, PythonErrorNode, ConceptDetectedError
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -118,4 +118,4 @@ class TestPythonParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(res.value, BuiltinConcepts.NOT_FOR_ME)
|
||||
assert res.value.reason == [ConceptDetected(expected_id)]
|
||||
assert res.value.reason == [ConceptDetectedError(expected_id)]
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import pytest
|
||||
from core.builtin_concepts import BuiltinConcepts
|
||||
from core.sheerka.services.SheerkaExecute import ParserInput
|
||||
from parsers.RuleParser import RuleParser, RuleNotFound
|
||||
from parsers.RuleParser import RuleParser, RuleNotFoundError
|
||||
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
|
||||
@@ -59,7 +59,7 @@ class TestRuleParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
assert not res.status
|
||||
assert sheerka.isinstance(error, BuiltinConcepts.ERROR)
|
||||
assert errors_causes == [RuleNotFound("999999")]
|
||||
assert errors_causes == [RuleNotFoundError("999999")]
|
||||
|
||||
def test_i_can_parse_rule(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
|
||||
@@ -9,7 +9,7 @@ from parsers.BaseNodeParser import utnode, cnode, short_cnode, UnrecognizedToken
|
||||
SCWC, CNC, UTN, SCN, CN
|
||||
from parsers.PythonParser import PythonNode
|
||||
from parsers.SyaNodeParser import SyaNodeParser, SyaConceptParserHelper, SyaAssociativity, \
|
||||
NoneAssociativeSequenceErrorNode, TooManyParametersFound, InFixToPostFix, ParenthesisMismatchErrorNode
|
||||
NoneAssociativeSequenceError, TooManyParametersFoundError, InFixToPostFix, ParenthesisMismatchError
|
||||
|
||||
import tests.parsers.parsers_utils
|
||||
from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
|
||||
@@ -758,12 +758,12 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
|
||||
res = parser.infix_to_postfix(context, ParserInput(expression))
|
||||
|
||||
assert len(res) == 1
|
||||
assert res[0].errors == [ParenthesisMismatchErrorNode(expected)]
|
||||
assert res[0].errors == [ParenthesisMismatchError(expected)]
|
||||
|
||||
def test_i_can_detect_parenthesis_mismatch_error_special_case(self):
|
||||
sheerka, context, parser = self.init_parser()
|
||||
expression = "one ? function( : two"
|
||||
expected = [ParenthesisMismatchErrorNode(("(", 5)), ParenthesisMismatchErrorNode(("(", 5))]
|
||||
expected = [ParenthesisMismatchError(("(", 5)), ParenthesisMismatchError(("(", 5))]
|
||||
res = parser.infix_to_postfix(context, ParserInput(expression))
|
||||
|
||||
assert len(res) == 1
|
||||
@@ -780,7 +780,7 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
|
||||
assert len(res) == 1
|
||||
assert len(res[0].errors) == 1
|
||||
error = res[0].errors[0]
|
||||
assert isinstance(error, TooManyParametersFound)
|
||||
assert isinstance(error, TooManyParametersFoundError)
|
||||
assert error.concept == cmap[expected[0]]
|
||||
assert error.token.value == expected[1]
|
||||
|
||||
@@ -897,7 +897,7 @@ class TestSyaNodeParser(TestUsingMemoryBasedSheerka):
|
||||
|
||||
res = parser.infix_to_postfix(context, ParserInput("one less than two less than three"))
|
||||
assert len(res) == 1
|
||||
assert res[0].errors == [NoneAssociativeSequenceErrorNode(concepts_map["less than"], 2, 8)]
|
||||
assert res[0].errors == [NoneAssociativeSequenceError(concepts_map["less than"], 2, 8)]
|
||||
|
||||
def test_i_can_post_fix_bnf_definition(self):
|
||||
"""
|
||||
|
||||
@@ -38,38 +38,6 @@ class TestSheerkaPromptCompleter(TestUsingMemoryBasedSheerka):
|
||||
assert as_dict["quit"].display_text == "quit"
|
||||
assert as_dict["quit"].display_meta_text == "command"
|
||||
|
||||
def test_i_can_complete_with_pipeable(self):
|
||||
sheerka = self.get_sheerka()
|
||||
|
||||
document = Document("| ")
|
||||
completions = SheerkaPromptCompleter(sheerka).get_completions(document, CompleteEvent())
|
||||
as_dict = {c.display_text: c for c in completions}
|
||||
assert "first" in as_dict
|
||||
assert as_dict["first"].text == "first()"
|
||||
assert as_dict["first"].display_text == "first"
|
||||
assert as_dict["first"].display_meta_text == "builtin"
|
||||
|
||||
assert "filter" in as_dict
|
||||
assert as_dict["filter"].text == "filter("
|
||||
assert as_dict["filter"].display_text == "filter"
|
||||
assert as_dict["filter"].display_meta_text == "builtin"
|
||||
|
||||
def test_i_can_complete_with_pipeable_when_starting_to_write(self):
|
||||
sheerka = self.get_sheerka()
|
||||
|
||||
document = Document("| f")
|
||||
completions = SheerkaPromptCompleter(sheerka).get_completions(document, CompleteEvent())
|
||||
as_dict = {c.display_text: c for c in completions}
|
||||
assert "first" in as_dict
|
||||
assert as_dict["first"].text == "first()"
|
||||
assert as_dict["first"].display_text == "first"
|
||||
assert as_dict["first"].display_meta_text == "builtin"
|
||||
|
||||
assert "filter" in as_dict
|
||||
assert as_dict["filter"].text == "filter("
|
||||
assert as_dict["filter"].display_text == "filter"
|
||||
assert as_dict["filter"].display_meta_text == "builtin"
|
||||
|
||||
@pytest.mark.parametrize("text, expected", [
|
||||
("func(", ["10", "20", "30"]),
|
||||
("func(1", ["10"]),
|
||||
@@ -95,17 +63,6 @@ class TestSheerkaPromptCompleter(TestUsingMemoryBasedSheerka):
|
||||
as_list = [c.display_text for c in completions]
|
||||
assert as_list == expected
|
||||
|
||||
@pytest.mark.parametrize("text, pos, expected", [
|
||||
("", 0, False),
|
||||
("foo", 3, False),
|
||||
("|", 1, True),
|
||||
("xxx | foo", 9, True),
|
||||
("xxx | foo", 5, True),
|
||||
("xxx | foo", 4, False),
|
||||
])
|
||||
def test_after_pipe(self, text, pos, expected):
|
||||
assert SheerkaPromptCompleter.after_pipe(text, pos) == expected
|
||||
|
||||
@pytest.mark.parametrize("text, pos, expected", [
|
||||
("", 0, ""),
|
||||
("foo", 3, "foo"),
|
||||
|
||||
Reference in New Issue
Block a user