Refactored sheerka class: splitted to use sub handlers. Refactored unit tests to use classes.

tests/parsers/test_ExactConceptParser.py

@@ -0,0 +1,138 @@
+from core.builtin_concepts import BuiltinConcepts
+from core.concept import Concept
+from core.tokenizer import Tokenizer
+from parsers.ExactConceptParser import ExactConceptParser
+
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+
+
+def metadata_prop(concept, prop_name):
+    for name, value in concept.metadata.props:
+        if name == prop_name:
+            return value
+
+    return None
+
+
+def get_concept(name, variables):
+    c = Concept(name=name)
+    if variables:
+        for v in variables:
+            c.def_prop(v)
+    c.init_key()
+    return c
+
+
+class TestExactConceptParser(TestUsingMemoryBasedSheerka):
+
+    def test_i_can_compute_combinations(self):
+        parser = ExactConceptParser()
+        res = parser.combinations(["foo", "bar", "baz"])
+
+        assert res == {('foo', 'bar', 'baz'),
+                       ('__var__0', 'bar', 'baz'),
+                       ('foo', '__var__0', 'baz'),
+                       ('foo', 'bar', '__var__0'),
+                       ('__var__0', '__var__1', 'baz'),
+                       ('__var__0', 'bar', '__var__1'),
+                       ('foo', '__var__0', '__var__1'),
+                       ('__var__0', '__var__1', '__var__2')}
+
+    def test_i_can_compute_combinations_with_duplicates(self):
+        parser = ExactConceptParser()
+        res = parser.combinations(["foo", "bar", "foo"])
+
+        assert res == {('foo', 'bar', 'foo'),
+                       ('__var__0', 'bar', '__var__0'),
+                       ('foo', '__var__0', 'foo'),
+                       ('__var__0', '__var__1', '__var__0'),
+                       ('__var__1', '__var__0', '__var__1')}
+        # TODO: the last tuple is not possible, so the algo can be improved
+
+    def test_i_can_recognize_a_simple_concept(self):
+        context = self.get_context()
+        concept = get_concept("hello world", [])
+        context.sheerka.add_in_cache(concept)
+
+        source = "hello world"
+        results = ExactConceptParser().parse(context, source)
+
+        assert len(results) == 1
+        assert results[0].status
+        assert results[0].value.value == concept
+
+    def test_i_can_recognize_concepts_defined_several_times(self):
+        context = self.get_context()
+        context.sheerka.add_in_cache(get_concept("hello world", []))
+        context.sheerka.add_in_cache(get_concept("hello a", ["a"]))
+
+        source = "hello world"
+        results = ExactConceptParser().parse(context, source)
+
+        assert len(results) == 2
+        results = sorted(results, key=lambda x: x.value.value.name)  # because of the usage of sets
+
+        assert results[0].status
+        assert results[0].value.value.name == "hello a"
+        assert metadata_prop(results[0].value.value, "a") == "world"
+
+        assert results[1].status
+        assert results[1].value.value.name == "hello world"
+
+    def test_i_can_recognize_a_concept_with_variables(self):
+        context = self.get_context()
+        concept = get_concept("a + b", ["a", "b"])
+        context.sheerka.add_in_cache(concept)
+        source = "10 + 5"
+        results = ExactConceptParser().parse(context, source)
+
+        assert len(results) == 1
+        assert results[0].status
+        concept_found = results[0].value.value
+        assert concept_found.key == concept.key
+        assert metadata_prop(concept_found, "a") == "10"
+        assert metadata_prop(concept_found, "b") == "5"
+
+    def test_i_can_recognize_a_concept_with_duplicate_variables(self):
+        context = self.get_context()
+        concept = get_concept("a + b + a", ["a", "b"])
+        context.sheerka.cache_by_key[concept.key] = concept
+        source = "10 + 5 + 10"
+        results = ExactConceptParser().parse(context, source)
+
+        assert len(results) == 1
+        assert results[0].status
+        concept_found = results[0].value.value
+        assert concept_found.key == concept.key
+        assert metadata_prop(concept_found, "a") == "10"
+        assert metadata_prop(concept_found, "b") == "5"
+
+    def test_i_can_manage_unknown_concept(self):
+        context = self.get_context()
+        source = "def concept hello world"  # this is not a concept by itself
+        res = ExactConceptParser().parse(context, source)
+
+        assert not res.status
+        assert context.sheerka.isinstance(res.value, BuiltinConcepts.UNKNOWN_CONCEPT)
+        assert res.value.body == "def concept hello world"
+
+    def test_i_can_detect_concepts_too_long(self):
+        context = self.get_context()
+        source = "a very very long concept that cannot be an unique one"
+        res = ExactConceptParser().parse(context, source)
+
+        assert not res.status
+        assert context.sheerka.isinstance(res.value, BuiltinConcepts.CONCEPT_TOO_LONG)
+        assert res.value.body == "a very very long concept that cannot be an unique one"
+
+    def test_i_can_detect_concept_from_tokens(self):
+        context = self.get_context()
+        concept = get_concept("hello world", [])
+        context.sheerka.add_in_cache(concept)
+
+        source = "hello world"
+        results = ExactConceptParser().parse(context, list(Tokenizer(source)))
+
+        assert len(results) == 1
+        assert results[0].status
+        assert results[0].value.value == concept