Added ModifyConcept function, and fixed 'isa' not working

tests/core/test_SheerkaCreateNewConcept.py

@@ -1,5 +1,6 @@
 from core.builtin_concepts import BuiltinConcepts
 from core.concept import PROPERTIES_TO_SERIALIZE, Concept
+from core.sheerka.Sheerka import Sheerka
 from sdp.sheerkaDataProvider import SheerkaDataProvider
 
 from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
@@ -25,7 +26,10 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
         assert concept.key in sheerka.cache_by_key
         assert concept.id in sheerka.cache_by_id
         assert sheerka.sdp.io.exists(
-            sheerka.sdp.io.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_found.get_digest()))
+            sheerka.sdp.io.get_obj_path(SheerkaDataProvider.ObjectsFolder, concept_found.get_origin()))
+        assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_HASH_ENTRY, concept.get_definition_hash())
+        assert sheerka.sdp.exists(Sheerka.CONCEPTS_BY_ID_ENTRY, concept.id)
+        assert sheerka.sdp.exists(Sheerka.CONCEPTS_ENTRY, concept.key)
 
     def test_i_cannot_add_the_same_concept_twice(self):
         """
@@ -77,7 +81,7 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
         concept = self.get_default_concept()
         sheerka.create_new_concept(self.get_context(sheerka), concept)
 
-        sheerka.cache_by_key = {}  # reset the cache
+        sheerka.reset_cache()
         loaded = sheerka.get(concept.key)
 
         assert loaded == concept
@@ -86,6 +90,16 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
         loaded = sheerka.sdp.get(sheerka.CONCEPTS_BY_ID_ENTRY, concept.id)
         assert loaded == concept
 
+    def test_i_can_instantiate_a_concept_from_sdp(self):
+        sheerka = self.get_sheerka()
+        concept = Concept("foo")
+        sheerka.create_new_concept(self.get_context(sheerka), concept)
+
+        sheerka.reset_cache()
+        loaded = sheerka.new("foo")
+
+        assert loaded == concept
+
     def test_i_can_get_a_concept_by_its_id(self):
         sheerka = self.get_sheerka()
         concept = self.get_default_concept()
@@ -105,6 +119,8 @@ class TestSheerkaCreateNewConcept(TestUsingMemoryBasedSheerka):
         res1 = sheerka.create_new_concept(self.get_context(sheerka), concept1)
         res2 = sheerka.create_new_concept(self.get_context(sheerka), concept2)
 
+        assert res1.status
+        assert res2.status
         assert res1.value.body.key == res2.value.body.key  # same key
 
         sheerka.cache_by_key = {}  # reset the cache

tests/core/test_SheerkaModifyConcept.py

@@ -0,0 +1,104 @@
+import pytest
+from core.builtin_concepts import BuiltinConcepts
+from core.concept import Concept, ConceptParts
+from core.sheerka.Sheerka import Sheerka
+
+from tests.TestUsingMemoryBasedSheerka import TestUsingMemoryBasedSheerka
+
+
+class TestSheerkaModifyConcept(TestUsingMemoryBasedSheerka):
+    def test_i_can_modify_a_concept(self):
+        sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True)
+
+        foo_instance = sheerka.new("foo")
+        foo_instance.metadata.body = "value"
+        foo_instance.set_prop(BuiltinConcepts.ISA, bar)
+        foo_instance.set_metadata_value(ConceptParts.BODY, "body value")
+        res = sheerka.modify_concept(context, foo_instance)
+
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
+        assert res.body.body.metadata.body == "value"
+        assert res.body.body.get_prop(BuiltinConcepts.ISA) == bar
+        assert res.body.body.body == "body value"
+
+        # test that object
+        sheerka.reset_cache()
+        foo_from_sheerka = sheerka.new("foo")
+        assert foo_from_sheerka.metadata.body == "value"
+        assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
+        assert foo_from_sheerka.body == "body value"
+
+        # test that ref by id is updated
+        sheerka.reset_cache()
+        foo_from_sheerka = sheerka.get_by_id(foo.id)
+        assert foo_from_sheerka.metadata.body == "value"
+        assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
+        assert foo_from_sheerka.body == "body value"
+
+        # test that ref by hash is updated
+        foo_from_sdp = sheerka.sdp.get(Sheerka.CONCEPTS_BY_HASH_ENTRY, foo_instance.get_definition_hash())
+        assert foo_from_sdp.metadata.body == "value"
+        assert foo_from_sdp.get_prop(BuiltinConcepts.ISA) == bar
+        assert foo_from_sdp.body == "body value"
+
+        # previous ref by hash is removed (since that definition hash has changed)
+        with pytest.raises(IndexError):
+            sheerka.sdp.get(Sheerka.CONCEPTS_BY_HASH_ENTRY, foo_instance.get_original_definition_hash())
+
+    def test_i_can_modify_concept_modifying_only_properties_and_body(self):
+        sheerka, context, foo, bar = self.init_concepts("foo", "bar", create_new=True)
+
+        foo_instance = sheerka.new("foo")
+        foo_instance.set_prop(BuiltinConcepts.ISA, bar)
+        foo_instance.set_metadata_value(ConceptParts.BODY, "body value")
+        res = sheerka.modify_concept(context, foo_instance)
+
+        assert res.status
+
+        foo_from_sheerka = sheerka.new("foo")
+        assert foo_from_sheerka.get_prop(BuiltinConcepts.ISA) == bar
+        assert foo_from_sheerka.body == "body value"
+
+    def test_cache_is_updated_when_a_concept_is_modified(self):
+        sheerka, context, foo = self.init_concepts("foo", create_new=True)
+
+        foo_instance = sheerka.new("foo")
+        foo_instance.metadata.body = "value"
+        res = sheerka.modify_concept(context, foo_instance)
+        assert res.status
+
+        foo_from_sheerka = sheerka.get("foo")
+        assert foo_from_sheerka.metadata.body == "value"
+
+        foo_by_id_from_sheerka = sheerka.get_by_id(foo.id)
+        assert foo_by_id_from_sheerka.metadata.body == "value"
+
+    def test_i_cannot_modify_a_concept_that_does_not_exists(self):
+        sheerka, context, foo = self.init_concepts("foo", create_new=False)
+
+        foo_instance = sheerka.new("foo")
+        foo_instance.metadata.body = "value"
+        res = sheerka.modify_concept(context, foo_instance)
+
+        assert not res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.UNKNOWN_CONCEPT)
+        assert res.body.body.key == foo.key
+
+    def test_i_can_modify_a_concept_that_is_in_a_list(self):
+        sheerka, context, foo1, foo2 = self.init_concepts(
+            Concept("foo", body="1"),
+            Concept("foo", body="2"), create_new=True)
+
+        foo2_instance = sheerka.new("foo")[1]
+        foo2_instance.metadata.body = "value"
+
+        res = sheerka.modify_concept(context, foo2_instance)
+        assert res.status
+        assert sheerka.isinstance(res.body, BuiltinConcepts.NEW_CONCEPT)
+        assert res.body.body.metadata.body == "value"
+
+        sheerka.reset_cache()
+        foo_from_sheerka = sheerka.new("foo")
+        assert foo_from_sheerka[0].metadata.body == "1"
+        assert foo_from_sheerka[1].metadata.body == "value"

tests/core/test_SheerkaSetsManager.py

@@ -200,8 +200,10 @@ class TestSheerkaSetsManager(TestUsingFileBasedSheerka):
         assert sheerka.isinset(twenty_one, number)
 
     def test_i_can_set_isa(self):
-        sheerka, context, foo, all_foos = self.init_concepts(Concept("foo"), Concept("all_foo"), use_dict=False)
-        sheerka.create_new_concept(context, foo)
+        sheerka, context, foo, all_foos = self.init_concepts(
+            "foo", "all_foo",
+            create_new=True,
+            use_dict=False)
 
         assert BuiltinConcepts.ISA not in foo.props
 

tests/core/test_concept.py

@@ -198,6 +198,9 @@ def test_i_can_update_from():
         id="123456"
     ).def_prop("a", "10").def_prop("b", None)
 
+    # make sure origin is preserved
+    setattr(template, "##origin##", "digest")
+
     template.values[ConceptParts.BODY] = "value in body"
     template.values[ConceptParts.WHERE] = "value in where"
     template.values[ConceptParts.PRE] = "value in pre"
@@ -208,3 +211,4 @@ def test_i_can_update_from():
     concept = Concept().update_from(template)
 
     assert concept == template
+    assert getattr(concept, "##origin##") == "digest"