First version of explain. Creating a new parser was a wrong approach. Need to reimplement

tests/parsers/test_ExpressionParser.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+
+from core.builtin_concepts import BuiltinConcepts, ReturnValueConcept
+from core.concept import Concept
+from parsers.ExpressionParser import PropertyEqualsNode, PropertyEqualsSequenceNode, PropertyContainsNode, AndNode, \
+    OrNode, NotNode, LambdaNode, IsaNode
+
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+
+
+@dataclass
+class Obj:
+    prop_a: object
+    prop_b: object = None
+    prop_c: object = None
+    parent: object = None
+
+
+class TestExpressionParser(TestUsingMemoryBasedSheerka):
+
+    def test_i_can_test_property_equals(self):
+        node = PropertyEqualsNode("prop_a", "good value")
+
+        assert node.eval(Obj(prop_a="good value"))
+        assert not node.eval(Obj(prop_a="other value"))
+
+    def test_i_can_test_property_equals_for_int(self):
+        node = PropertyEqualsNode("prop_a", "1")
+
+        assert node.eval(Obj(prop_a=1))
+        assert node.eval(Obj(prop_a="1"))
+
+    def test_i_can_test_property_equals_sequence(self):
+        node = PropertyEqualsSequenceNode(["prop_b", "prop_a"], ["good parent", "good child"])
+
+        assert node.eval(Obj(prop_a="good child", parent=Obj(prop_a="Don't care", prop_b="good parent")))
+        assert not node.eval(Obj(prop_a="good child", parent=Obj(prop_a="Don't care", prop_b="wrong parent")))
+        assert not node.eval(Obj(prop_a="good child"))
+        assert not node.eval(Obj(prop_a="wrong child", parent=Obj(prop_a="Don't care", prop_b="good parent")))
+
+    def test_i_can_test_property_contains(self):
+        node = PropertyContainsNode("prop_a", "substring")
+
+        assert node.eval(Obj(prop_a="it contains substring in it"))
+        assert not node.eval(Obj(prop_a="it does not"))
+
+    def test_i_can_test_property_contains_for_int(self):
+        node = PropertyContainsNode("prop_a", "44")
+
+        assert node.eval(Obj(prop_a=123445))
+        assert not node.eval(Obj(prop_a=12435))
+
+    def test_i_can_test_and(self):
+        left = PropertyEqualsNode("prop_a", "good a")
+        right = PropertyEqualsNode("prop_b", "good b")
+        other = PropertyEqualsNode("prop_c", "good c")
+        and_node = AndNode(left, right, other)
+
+        assert and_node.eval(Obj("good a", "good b", "good c"))
+        assert not and_node.eval(Obj("wrong a", "good b", "good c"))
+        assert not and_node.eval(Obj("good a", "wrong b", "good c"))
+        assert not and_node.eval(Obj("good a", "good b", "wrong c"))
+
+    def test_i_can_test_or(self):
+        left = PropertyEqualsNode("prop_a", "good a")
+        right = PropertyEqualsNode("prop_b", "good b")
+        other = PropertyEqualsNode("prop_c", "good c")
+        or_node = OrNode(left, right, other)
+
+        assert or_node.eval(Obj("wrong a", "good b", "good c"))
+        assert or_node.eval(Obj("good a", "wrong b", "good c"))
+        assert or_node.eval(Obj("good a", "good b", "wrong c"))
+        assert not or_node.eval(Obj("wrong a", "wrong b", "wrong c"))
+
+    def test_i_can_test_not(self):
+        node = PropertyEqualsNode("prop_a", "good value")
+        not_node = NotNode(node)
+
+        assert not not_node.eval(Obj(prop_a="good value"))
+        assert not_node.eval(Obj(prop_a="wrong value"))
+
+    def test_i_can_test_lambda_node(self):
+        node = LambdaNode(lambda o: o.prop_a + o.prop_b == "ab")
+
+        assert node.eval(Obj(prop_a="a", prop_b="b"))
+        assert not node.eval(Obj(prop_a="wrong value", prop_b="wrong value"))
+        assert not node.eval(Obj(prop_a="wrong value"))  # exception is caught
+
+    def test_i_can_test_isa_node(self):
+        class_node = IsaNode(Obj)
+        assert class_node.eval(Obj(prop_a="value"))
+        assert not class_node.eval(TestExpressionParser())
+
+        concept_node = IsaNode(BuiltinConcepts.RETURN_VALUE)
+        assert concept_node.eval(ReturnValueConcept())
+        assert concept_node.eval(Concept(name="foo", key=BuiltinConcepts.RETURN_VALUE))
+        assert not concept_node.eval(Obj)
+        assert not concept_node.eval(Concept())
+
+        concept_node2 = IsaNode("foo")
+        assert concept_node2.eval(Concept("foo").init_key())
+        assert not concept_node2.eval(Obj)
+        assert not concept_node2.eval(Concept())