Fixed error when desc() returns multiple results

tests/evaluators/EvaluatorTestsUtils.py

@@ -0,0 +1,50 @@
+from core.builtin_concepts import ReturnValueConcept, BuiltinConcepts
+from core.concept import Concept
+from evaluators.BaseEvaluator import BaseEvaluator
+from parsers.BaseParser import BaseParser
+
+reduced_requested = ReturnValueConcept("Sheerka", True, Concept(name=BuiltinConcepts.REDUCE_REQUESTED,
+                                                                key=BuiltinConcepts.REDUCE_REQUESTED))
+
+
+def ret_val(value="value", who="who", status=True):
+    return ReturnValueConcept(who, status, value)
+
+
+def p_ret_val(value="value", parser="parser", status=True):
+    return ReturnValueConcept(BaseParser.PREFIX + parser, status, value)
+
+
+def e_ret_val(value="value", evaluator="evaluator", status=True):
+    return ReturnValueConcept(BaseEvaluator.PREFIX + evaluator, status, value)
+
+
+def p_ret_val_false(value="value", parser="parser"):
+    return p_ret_val(value, parser, status=False)
+
+
+def p_ret_val_true(value="value", parser="parser"):
+    return p_ret_val(value, parser, status=True)
+
+
+def e_ret_val_false(value="value", parser="parser"):
+    return e_ret_val(value, parser, status=False)
+
+
+def e_ret_val_true(value="value", parser="parser"):
+    return e_ret_val(value, parser, status=True)
+
+
+def e_ret_val_new(key, evaluator="evaluator", status=True, **kwargs):
+    body = new_concept(key, **kwargs)
+    return e_ret_val(body, evaluator, status)
+
+
+def new_concept(key, **kwargs):
+    res = Concept(key=key, name=key, is_builtin=False, is_unique=False)
+    for k, v in kwargs.items():
+        to_use = "#" + k + "#" if k in ("body", "pre", "post", "ret") else k
+        res.set_value(to_use, v)
+
+    res.get_metadata().is_evaluated = True
+    return res

tests/evaluators/test_MultipleOutEvaluator.py

@@ -0,0 +1,55 @@
+import pytest
+from core.builtin_concepts import BuiltinConcepts
+from evaluators.MultipleOutEvaluator import MultipleOutEvaluator
+
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+from tests.evaluators.EvaluatorTestsUtils import reduced_requested, e_ret_val_new, p_ret_val_false, p_ret_val_true, \
+    e_ret_val_false, e_ret_val
+
+
+class TestMultipleOutEvaluator(TestUsingMemoryBasedSheerka):
+
+    @pytest.mark.parametrize("return_values, expected", [
+        ([reduced_requested,
+          e_ret_val_new(BuiltinConcepts.TO_DICT, body={}),
+          e_ret_val_new(BuiltinConcepts.TO_DICT, body={}),
+          p_ret_val_false("value"),
+          e_ret_val_false()], True),
+
+        # only one to_dict
+        ([reduced_requested, e_ret_val_new(BuiltinConcepts.TO_DICT, body={})], False),
+
+        # reduce request missing
+        ([e_ret_val_new(BuiltinConcepts.TO_DICT, body={}), e_ret_val_new(BuiltinConcepts.TO_DICT, body={})], False),
+
+        # parser result not evaluated
+        ([reduced_requested,
+          e_ret_val_new(BuiltinConcepts.TO_DICT, body={}),
+          e_ret_val_new(BuiltinConcepts.TO_DICT, body={}),
+          p_ret_val_true("value")], False),
+    ])
+    def test_i_can_match(self, return_values, expected):
+        sheerka, context = self.init_concepts()
+        evaluator = MultipleOutEvaluator()
+
+        assert evaluator.matches(context, return_values) == expected
+
+    def test_i_can_eval(self):
+        sheerka, context = self.init_concepts()
+        evaluator = MultipleOutEvaluator()
+
+        first_out = sheerka.new(BuiltinConcepts.TO_DICT, body={"a": 1})
+        second_out = sheerka.new(BuiltinConcepts.TO_DICT, body={"b": 1})
+
+        return_values = [reduced_requested,
+                         e_ret_val(first_out),
+                         e_ret_val(second_out),
+                         p_ret_val_false("value"),
+                         e_ret_val_false()]
+
+        evaluator.matches(context, return_values)
+        res = evaluator.eval(context, return_values)
+
+        assert sheerka.isinstance(res, BuiltinConcepts.RETURN_VALUE)
+        assert res.body == sheerka.new(BuiltinConcepts.TO_MULTI, body=[first_out, second_out])
+        assert res.parents == return_values