Fixed #20: I can parse simple concepts

tests/services/test_ConceptManager.py

@@ -6,8 +6,8 @@ from conftest import NewOntology
 from core.BuiltinConcepts import BuiltinConcepts
 from core.concept import ConceptMetadata
 from core.error import ErrorContext
-from helpers import get_concepts, get_metadata
-from services.SheerkaConceptManager import ConceptAlreadyDefined, ConceptManager
+from helpers import get_concept, get_concepts, get_metadata
+from services.SheerkaConceptManager import ConceptAlreadyDefined, ConceptManager, ConceptRef
 
 
 class TestConceptManager(BaseTest):
@@ -86,7 +86,7 @@ class TestConceptManager(BaseTest):
             assert metadata.name == "name"
             assert metadata.key == "name"
             assert metadata.body == "body"
-            assert metadata.digest == "c75faa4efbc9ef9dbc5174c52786d5b066e2ece41486b81c27336e292917fecb"
+            assert metadata.digest == "f32363f42e698b1642c8f76f969d76d56f53f0e0732cb651e3360e3ede7b2b11"
             assert metadata.all_attrs == ('#where#', '#pre#', '#post#', '#body#', '#ret#')
 
             # is sorted in db
@@ -96,6 +96,60 @@ class TestConceptManager(BaseTest):
             assert om.get(ConceptManager.CONCEPTS_BY_KEY_ENTRY, metadata.key) == metadata
             assert om.get(ConceptManager.CONCEPTS_BY_HASH_ENTRY, metadata.digest) == metadata
 
+            # check first token
+            assert om.get(ConceptManager.CONCEPT_BY_FIRST_TOKEN_IN_KEY, "name") == ["1001"]
+
+    def test_i_can_define_a_new_concept_with_variables(self, context, service):
+        with NewOntology(context, "test_i_can_define_a_new_concept_with_variables"):
+            res = service.define_new_concept(context,
+                                             name="a multiplied by b",
+                                             variables=[("a", NotInit), ("b", NotInit)])
+
+            metadata = res.value.metadata
+            assert isinstance(metadata, ConceptMetadata)
+            assert metadata.id == "1001"
+            assert metadata.name == "a multiplied by b"
+            assert metadata.key == "__var__0 multiplied by __var__1"
+            assert metadata.digest == "17d2360d82fc4264e2bcb75e4aa30ee3de87531acee72f5d939e23bff246b2dd"
+            assert metadata.all_attrs == ('#where#', '#pre#', '#post#', '#body#', '#ret#', "a", "b")
+
+            # is sorted in db
+            om = context.sheerka.om
+            assert om.get(ConceptManager.CONCEPTS_BY_ID_ENTRY, metadata.id) == metadata
+            assert om.get(ConceptManager.CONCEPTS_BY_NAME_ENTRY, metadata.name) == metadata
+            assert om.get(ConceptManager.CONCEPTS_BY_KEY_ENTRY, metadata.key) == metadata
+            assert om.get(ConceptManager.CONCEPTS_BY_HASH_ENTRY, metadata.digest) == metadata
+
+            # check first token
+            assert om.get(ConceptManager.CONCEPT_BY_FIRST_TOKEN_IN_KEY, "multiplied") == ["1001"]
+
+    def test_i_can_define_a_new_concept_using_definition(self, context, service):
+        with NewOntology(context, "test_i_can_define_a_new_concept_using_definition"):
+            res = service.define_new_concept(context,
+                                             name="multiplication",
+                                             definition="a multiplied by b",
+                                             variables=[("a", NotInit), ("b", NotInit)])
+
+            metadata = res.value.metadata
+            assert isinstance(metadata, ConceptMetadata)
+            assert metadata.id == "1001"
+            assert metadata.name == "multiplication"
+            assert metadata.definition == "a multiplied by b"
+            assert metadata.key == "__var__0 multiplied by __var__1"
+            assert metadata.digest == "b29007ea67bddc48329a2ae0124a320e26c86fb6b106aad6581bc75dfdf5ebeb"
+            assert metadata.all_attrs == ('#where#', '#pre#', '#post#', '#body#', '#ret#', "a", "b")
+
+            # is sorted in db
+            om = context.sheerka.om
+            assert om.get(ConceptManager.CONCEPTS_BY_ID_ENTRY, metadata.id) == metadata
+            assert om.get(ConceptManager.CONCEPTS_BY_NAME_ENTRY, metadata.name) == metadata
+            assert om.get(ConceptManager.CONCEPTS_BY_KEY_ENTRY, metadata.key) == metadata
+            assert om.get(ConceptManager.CONCEPTS_BY_HASH_ENTRY, metadata.digest) == metadata
+
+            # check first token
+            assert om.get(ConceptManager.CONCEPT_BY_FIRST_TOKEN_IN_KEY, "multiplied") == ["1001"]
+            assert om.get(ConceptManager.CONCEPT_BY_FIRST_TOKEN_IN_NAME, "multiplication") == ["1001"]
+
     def test_i_cannot_create_the_same_concept_twice(self, context, service):
         with NewOntology(context, "test_i_cannot_create_the_same_concept_twice"):
             res = service.define_new_concept(context, "name", body="body")
@@ -176,11 +230,11 @@ class TestConceptManager(BaseTest):
     def test_i_cannot_instantiate_a_concept_which_does_not_exist(self, context, service):
         foo = service.newn("foo", var1="value1", var2="value2")
         assert foo.key == BuiltinConcepts.UNKNOWN_CONCEPT
-        assert foo.requested_name == "foo"
+        assert foo.requested == "foo"
 
         foo = service.newi("1001", var1="value1", var2="value2")
         assert foo.key == BuiltinConcepts.UNKNOWN_CONCEPT
-        assert foo.requested_id == "1001"
+        assert foo.requested == "#1001"
 
     def test_i_can_instantiate_by_name_when_multiple_results(self, context, service):
         with NewOntology(context, "test_i_can_instantiate_by_name_when_multiple_results"):
@@ -255,6 +309,48 @@ class TestConceptManager(BaseTest):
             assert context.sheerka.isinstance(res[0], foo)
             assert context.sheerka.isinstance(res[1], bar)
 
+    def test_i_can_new_using_concept_reference(self, context, service):
+        with NewOntology(context, "test_i_can_new_using_concept_reference"):
+            foo, bar, baz = get_concepts(context, "foo", "bar", "baz", use_sheerka=True)
+
+            foo.get_runtime_info().info["resolution_method"] = "id"
+            bar.get_runtime_info().info["resolution_method"] = "key"
+
+            foo_concept_ref = ConceptRef(foo)
+            res = service.new(foo_concept_ref)
+            assert context.sheerka.isinstance(res, foo)
+
+            bar_concept_ref = ConceptRef(bar)
+            res = service.new(bar_concept_ref)
+            assert context.sheerka.isinstance(res, bar)
+
+            baz_concept_ref = ConceptRef(baz)
+            res = service.new(baz_concept_ref)
+            assert context.sheerka.isinstance(res, baz)
+
+    def test_i_can_new_using_concept_reference_when_multiple_results(self, context, service):
+        with NewOntology(context, "test_i_can_new_using_concept_reference"):
+            foo1, foo2 = get_concepts(context,
+                                      get_concept("foo", body="1"),
+                                      get_concept("foo", body="2"),
+                                      use_sheerka=True)
+
+            foo = get_concept("foo")  # blueprint, no need to be known by Sheerka
+            foo.get_runtime_info().info["resolution_method"] = "name"
+            foo_concept_ref = ConceptRef(foo)
+
+            res = service.new(foo_concept_ref)
+            assert res == [foo1, foo2]
+
+    def test_i_cannot_new_using_concept_reference_when_unknown(self, context, service):
+        foo = get_concept("foo")  # not known by Sheerka
+        foo.get_runtime_info().info["resolution_method"] = "name"
+
+        foo_concept_ref = ConceptRef(foo)
+        res = service.new(foo_concept_ref)
+        assert context.sheerka.isinstance(res, BuiltinConcepts.UNKNOWN_CONCEPT)
+        assert res.requested == "foo"
+
     def test_unknown_concept_is_return_if_the_identifier_is_not_found(self, service):
         assert service.new("unknown").name == BuiltinConcepts.UNKNOWN_CONCEPT