Implemented some enhancement requests

tests/evaluators/EvaluatorTestsUtils.py

@@ -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():

tests/evaluators/test_FormatRuleEvaluator.py

@@ -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)
 

tests/evaluators/test_MultipleSucessEvaluator.py

@@ -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]