Fixed #8

Fixed #12 Fixed #13 Fixed #14
2023-05-08 17:50:28 +02:00
parent 21a397861a
commit e41094f908
95 changed files with 12168 additions and 260 deletions
@@ -0,0 +1,183 @@
+import logging
+
+import pytest
+
+from base import BaseTest
+from common.global_symbols import NoFirstToken, NotFound, NotInit, Removed
+from helpers import get_concept, get_concepts
+from ontologies.SheerkaOntologyManager import SheerkaOntologyManager
+from parsers.tokenizer import Keywords
+from sheerkapickle import tags
+from sheerkapickle.sheerkaplicker import SheerkaPickler
+from sheerkapickle.sheerkaunpickler import SheerkaUnpickler
+
+
+class Obj:
+    def __init__(self, a, b, c):
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def __eq__(self, other):
+        if id(self) == id(other):
+            return True
+
+        if not isinstance(other, Obj):
+            return False
+
+        return self.a == other.a and self.b == other.b and self.c == other.c
+
+    def __hash__(self):
+        return hash((self.a, self.b, self.c))
+
+
+class TestSheerkaPickler(BaseTest):
+
+    @pytest.mark.parametrize("obj, expected", [
+        (1, 1),
+        (3.14, 3.14),
+        ("a string", "a string"),
+        (True, True),
+        (None, None),
+        ([1, 3.14, "a string"], [1, 3.14, "a string"]),
+        ((1, 3.14, "a string"), {tags.TUPLE: [1, 3.14, "a string"]}),
+        ({1}, {tags.SET: [1]}),
+        ({"a": "a", "b": 3.14, "c": True}, {"a": "a", "b": 3.14, "c": True}),
+        ({1: "a", 2: 3.14, 3: True}, {1: "a", 2: 3.14, 3: True}),
+        ([1, [3.14, "a string"]], [1, [3.14, "a string"]]),
+        ([1, (3.14, "a string")], [1, {tags.TUPLE: [3.14, "a string"]}]),
+        ([], []),
+        (Keywords.DEF, {tags.ENUM: 'parsers.tokenizer.Keywords.DEF'}),
+    ])
+    def test_i_can_flatten_and_restore_primitives(self, sheerka, obj, expected):
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+        assert flatten == expected
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj
+
+    @pytest.mark.parametrize("obj, expected", [
+        (NotInit, {tags.CUSTOM: NotInit.value}),
+        (NotFound, {tags.CUSTOM: NotFound.value}),
+        (Removed, {tags.CUSTOM: Removed.value}),
+        (NoFirstToken, {tags.CUSTOM: NoFirstToken.value}),
+    ])
+    def test_i_can_flatten_and_restore_custom_types(self, sheerka, obj, expected):
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+        assert flatten == expected
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj
+
+    def test_i_can_flatten_and_restore_instances(self, sheerka):
+        obj1 = Obj(1, "b", True)
+        obj2 = Obj(3.14, ("a", "b"), obj1)
+
+        flatten = SheerkaPickler(sheerka).flatten(obj2)
+        assert flatten == {'_sheerka/obj': 'tests.sheerkapickle.test_SheerkaPickler.Obj',
+                           'a': 3.14,
+                           'b': {'_sheerka/tuple': ['a', 'b']},
+                           'c': {'_sheerka/obj': 'tests.sheerkapickle.test_SheerkaPickler.Obj',
+                                 'a': 1,
+                                 'b': 'b',
+                                 'c': True}}
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj2
+
+    def test_i_can_manage_circular_reference(self, sheerka):
+        obj1 = Obj(1, "b", True)
+        obj1.c = obj1
+
+        flatten = SheerkaPickler(sheerka).flatten(obj1)
+        assert flatten == {'_sheerka/obj': 'tests.sheerkapickle.test_SheerkaPickler.Obj',
+                           'a': 1,
+                           'b': 'b',
+                           'c': {'_sheerka/id': 0}}
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded.a == obj1.a
+        assert decoded.b == obj1.b
+        assert decoded.c == decoded
+
+    def test_i_can_flatten_obj_with_new_props(self, sheerka):
+        # property 'z' is not part of the `Obj` definition
+        obj = Obj(1, "b", True)
+        obj.z = "new prop"
+
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+        assert flatten == {'_sheerka/obj': 'tests.sheerkapickle.test_SheerkaPickler.Obj',
+                           'a': 1,
+                           'b': 'b',
+                           'c': True,
+                           'z': "new prop"}
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj
+
+    def test_i_cannot_correctly_flatten_compiled_and_generator(self, sheerka):
+        obj = Obj((i for i in range(3)), compile("a + b", "<src>", mode="eval"), None)
+
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+
+        assert isinstance(flatten["a"], str)
+        assert flatten["a"].startswith("<generator object")
+        assert isinstance(flatten["b"], str)
+        assert flatten["b"].startswith("<code object")
+        assert flatten["c"] is None
+
+    @pytest.mark.parametrize("obj, expected", [
+        ({None: "a"}, {'null': "a"}),
+        ({Keywords.DEF: "a"}, {'parsers.tokenizer.Keywords.DEF': 'a'}),
+        ({(1, 2): "a"}, {(1, 2): "a"}),
+    ])
+    def test_i_can_manage_specific_keys_in_dictionaries(self, sheerka, obj, expected):
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+        assert flatten == expected
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj
+
+    @pytest.mark.skip("Concepts are not fully working")
+    def test_i_can_use_concept_as_dictionary_key(self, sheerka, context):
+        concept = get_concepts(context, "foo", use_sheerka=True)[0]
+
+        obj = {concept: "a"}
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+        assert flatten == {'c:foo|1001:': 'a'}
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj
+
+    def test_i_can_manage_references(self, sheerka):
+        foo = Obj("foo", "bar", "baz")
+        obj = [Keywords.DEF, foo, Keywords.WHERE, Keywords.DEF, foo]
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+
+        assert flatten == [{'_sheerka/enum': 'parsers.tokenizer.Keywords.DEF'},
+                           {'_sheerka/obj': 'tests.sheerkapickle.test_SheerkaPickler.Obj',
+                            'a': 'foo',
+                            'b': 'bar',
+                            'c': 'baz'},
+                           {'_sheerka/enum': 'parsers.tokenizer.Keywords.WHERE'},
+                           {'_sheerka/id': 0},
+                           {'_sheerka/id': 1}]
+
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == obj
+
+    def test_i_do_not_encode_logger(self, sheerka):
+        logger = logging.getLogger("log_name")
+        logger2 = logging.getLogger("log_name2")
+        obj = Obj("foo", logger, {"a": logger, "b": logger2})
+
+        flatten = SheerkaPickler(sheerka).flatten(obj)
+        decoded = SheerkaUnpickler(sheerka).restore(flatten)
+        assert decoded == Obj("foo", None, {"a": None, "b": None})
+
+    def test_ontology_are_not_serialized(self, sheerka, context):
+        om = SheerkaOntologyManager(sheerka, "mem://").freeze()
+        ontology = om.push_ontology("new ontology")
+
+        flatten = SheerkaPickler(sheerka).flatten(ontology)
+        assert flatten == "__ONTOLOGY:new ontology__"
@@ -0,0 +1,325 @@
+import pytest
+
+import sheerkapickle
+from base import BaseTest
+from core.concept import Concept
+
+
+def set_full_serialization(concept):
+    concept.get_metadata().full_serialization = True
+    return concept
+
+
+@pytest.mark.skip("Handler are not implemented")
+class TestSheerkaPickleHandler(BaseTest):
+
+    def test_i_can_encode_decode_unknown_concept_metadata(self, sheerka):
+        concept = set_full_serialization(Concept(name="foo", key="my_key"))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.key": "my_key"}'
+        assert decoded == concept
+
+        concept = set_full_serialization(Concept("foo", is_builtin=True, is_unique=True))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.is_builtin": true, "meta.is_unique": true}'
+
+        concept = set_full_serialization(Concept("foo", body="my_body"))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.body": "my_body"}'
+
+        concept = set_full_serialization(Concept("foo", pre="my_pre"))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.pre": "my_pre"}'
+
+        concept = set_full_serialization(Concept("foo", post="my_post"))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.post": "my_post"}'
+
+        concept = set_full_serialization(Concept("foo", where="my_where"))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.where": "my_where"}'
+
+        concept = set_full_serialization(Concept("foo").def_var("a", "value_a").def_var("b", "value_b"))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.variables": [["a", "value_a"], ["b", "value_b"]], "values": [["a", {"_sheerka/custom": "**NotInit**"}], ["b", {"_sheerka/id": 1}]]}'
+
+        concept = Concept("foo").init_key()
+        sheerka.define_new_concept(self.get_context(sheerka), concept)
+        concept.get_metadata().full_serialization = True
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.key": "foo", "meta.id": "1001"}'
+
+    def test_i_can_encode_decode_unknown_concept_values(self):
+        sheerka = self.get_sheerka()
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value(ConceptParts.PRE, 10)  # an int
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["#pre#", 10]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value(ConceptParts.POST, 'a string')  # an string
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["#post#", "a string"]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value(ConceptParts.WHERE, ['a string', 3.14])  # a list
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["#where#", ["a string", 3.14]]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value(ConceptParts.WHERE, ('a string', 3.14))  # a tuple
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["#where#", {"_sheerka/tuple": ["a string", 3.14]}]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value(ConceptParts.BODY, set_full_serialization(Concept("foo", body="foo_body")))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["#body#", {"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "meta.body": "foo_body"}]]}'
+
+    def test_i_can_encode_decode_unknown_concept_variables(self):
+        sheerka = self.get_sheerka()
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value("a", "value_a")  # string
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["a", "value_a"]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value("a", 10)  # int
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["a", 10]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value("a", set_full_serialization(Concept("bar")))  # another concept
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["a", {"_sheerka/obj": "core.concept.Concept", "meta.name": "bar"}]]}'
+
+        concept = set_full_serialization(Concept("foo"))
+        concept.set_value("a", "a").set_value("b", "b")  # at least two variables
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "foo", "values": [["a", "a"], ["b", "b"]]}'
+
+    def test_i_can_encode_decode_known_concepts(self):
+        sheerka = self.get_sheerka()
+
+        ref_concept = Concept("my_name", True, True, "my_key", "my_body", "my_where", "my_pre", "my_post", "my_def")
+        ref_concept.def_var("a", "value_a").def_var("b", "value_b")
+
+        sheerka.define_new_concept(self.get_context(sheerka), ref_concept)
+
+        to_string = sheerkapickle.encode(sheerka, ref_concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == ref_concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": "1001"}'
+
+        # same test, modify a value and check if this modification is correctly saved
+        concept = Concept().update_from(sheerka.get_by_id(ref_concept.id))
+        concept.set_value(ConceptParts.BODY, set_full_serialization(Concept("bar")))
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": "1001", "values": [["#body#", {"_sheerka/obj": "core.concept.Concept", "meta.name": "bar"}]]}'
+
+    def test_i_can_manage_reference_of_the_same_object(self):
+        sheerka = self.get_sheerka()
+
+        concept_ref = set_full_serialization(Concept("foo"))
+
+        concept = set_full_serialization(Concept("bar"))
+        concept.set_value(ConceptParts.PRE, concept_ref)
+        concept.set_value(ConceptParts.BODY, concept_ref)
+
+        to_string = sheerkapickle.encode(sheerka, concept)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == concept
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "meta.name": "bar", "values": [["#pre#", {"_sheerka/obj": "core.concept.Concept", "meta.name": "foo"}], ["#body#", {"_sheerka/id": 1}]]}'
+
+    def test_i_can_encode_decode_user_input(self):
+        sheerka = self.get_sheerka()
+
+        user_input = sheerka.new(BuiltinConcepts.USER_INPUT, body="my_text", user_name="my_user_name")
+
+        to_string = sheerkapickle.encode(sheerka, user_input)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == user_input
+        assert to_string == f'{{"_sheerka/obj": "core.builtin_concepts.UserInputConcept", "concept/id": ["__USER_INPUT", "{self.user_input_id}"], "user_name": "my_user_name", "text": "my_text"}}'
+
+    def test_i_can_encode_decode_user_input_when_tokens(self):
+        sheerka = self.get_sheerka()
+
+        text = "I have 'a complicated' 10 text"
+        tokens = list(Tokenizer(text))
+        user_input = sheerka.new(BuiltinConcepts.USER_INPUT, body=tokens, user_name="my_user_name")
+
+        to_string = sheerkapickle.encode(sheerka, user_input)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == sheerka.new(BuiltinConcepts.USER_INPUT, body=text, user_name="my_user_name")
+        assert to_string == f'{{"_sheerka/obj": "core.builtin_concepts.UserInputConcept", "concept/id": ["__USER_INPUT", "{self.user_input_id}"], "user_name": "my_user_name", "text": "{text}"}}'
+
+    def test_i_can_encode_decode_return_value(self):
+        sheerka = self.get_sheerka()
+
+        ret_val = sheerka.ret("who", True, 10)
+
+        to_string = sheerkapickle.encode(sheerka, ret_val)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == ret_val
+        assert to_string == f'{{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept", "concept/id": ["__RETURN_VALUE", "{self.return_value_id}"], "who": "who", "status": true, "value": 10}}'
+
+    def test_i_can_encode_decode_return_value_with_parent(self):
+        sheerka = self.get_sheerka()
+
+        ret_val = sheerka.ret("who", True, 10)
+        ret_val_parent = sheerka.ret("parent_who", True, "10")
+        ret_val.parents = [ret_val_parent, ret_val_parent]
+
+        to_string = sheerkapickle.encode(sheerka, ret_val)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == ret_val
+        assert decoded.parents == ret_val.parents
+        id_str = f', "concept/id": ["__RETURN_VALUE", "{self.return_value_id}"]'
+        parents_str = '[{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept"' + id_str + ', "who": "parent_who", "status": true, "value": "10"}, {"_sheerka/id": 1}]'
+        assert to_string == '{"_sheerka/obj": "core.builtin_concepts.ReturnValueConcept"' + id_str + ', "who": "who", "status": true, "value": 10, "parents": ' + parents_str + '}'
+
+    def test_i_can_encode_decode_return_values_with_complex_body(self):
+        sheerka = self.get_sheerka()
+
+        ret_val = sheerka.ret("who", True, set_full_serialization(Concept("foo", body="bar")))
+
+        to_string = sheerkapickle.encode(sheerka, ret_val)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == ret_val
+
+    def test_i_can_encode_decode_return_values_from_concepts_parsers_or_evaluators(self):
+        sheerka = self.get_sheerka()
+
+        foo = Concept("foo")
+        sheerka.set_id_if_needed(foo, False)
+        ret_val = sheerka.ret(foo, True, 10)
+        to_string = sheerkapickle.encode(sheerka, ret_val)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == sheerka.ret("c:1001:", True, 10)
+
+        ret_val = sheerka.ret(DefConceptParser(), True, 10)
+        to_string = sheerkapickle.encode(sheerka, ret_val)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == sheerka.ret("parsers.DefConcept", True, 10)
+
+        ret_val = sheerka.ret(ConceptEvaluator(), True, 10)
+        to_string = sheerkapickle.encode(sheerka, ret_val)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == sheerka.ret("evaluators.Concept", True, 10)
+
+    def test_i_can_encode_decode_execution_context(self):
+        sheerka = self.get_sheerka()
+        c = Concept("foo").def_var("a")
+        context = ExecutionContext("who", Event("xxx"), sheerka, BuiltinConcepts.EVALUATE_CONCEPT, c, "my desc")
+        input_list = [ReturnValueConcept("who", True, 10), ReturnValueConcept("who2", False, 20)]
+        context.inputs = {"a": input_list, "b": set_full_serialization(Concept("foo"))}
+        context.values = {"c": input_list, "d": set_full_serialization(Concept("bar"))}
+        context.obj = set_full_serialization(Concept("baz"))
+        context.push("who3", BuiltinConcepts.EVALUATING_CONCEPT, c, desc="sub_child1")
+        context.push("who4", BuiltinConcepts.EVALUATING_ATTRIBUTE, "a", desc="sub_child2")
+
+        to_string = sheerkapickle.encode(sheerka, context)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+        assert decoded == context
+
+    def test_complicated_execution_context(self):
+        sheerka = self.get_sheerka(skip_builtins_in_db=False)
+
+        text = "def concept one as 1"
+        execution_context = ExecutionContext("s", Event(), sheerka, BuiltinConcepts.NOP, None, f"Evaluating '{text}'")
+        user_input = sheerka.ret("s", True, sheerka.new(BuiltinConcepts.USER_INPUT, body=text, user_name="n"))
+        reduce_requested = sheerka.ret("s", True, sheerka.new(BuiltinConcepts.REDUCE_REQUESTED))
+
+        steps = [
+            BuiltinConcepts.BEFORE_PARSING,
+            BuiltinConcepts.PARSING,
+            BuiltinConcepts.AFTER_PARSING,
+            BuiltinConcepts.BEFORE_EVALUATION,
+            BuiltinConcepts.EVALUATION,
+            BuiltinConcepts.AFTER_EVALUATION
+        ]
+
+        ret = sheerka.execute(execution_context, [user_input, reduce_requested], steps)
+        execution_context.add_values(return_values=ret)
+
+        to_string = sheerkapickle.encode(sheerka, execution_context)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+
+        return_value = decoded.values["return_values"][0].value
+        assert sheerka.isinstance(return_value, BuiltinConcepts.NEW_CONCEPT)
+
+    def test_encode_simple_concept(self):
+        sheerka = self.get_sheerka()
+
+        foo = set_full_serialization(Concept("foo"))
+        to_string = sheerkapickle.encode(sheerka, foo)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+
+        assert decoded == foo
+
+    def test_i_can_encode_decode_rule(self):
+        sheerka = self.get_sheerka()
+
+        rule = Rule("print", "my rule", "True", "Hello world")
+        rule.metadata.id = "1"
+
+        to_string = sheerkapickle.encode(sheerka, rule)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+
+        assert to_string == '{"_sheerka/obj": "core.rule.Rule", "rule/id": "1", "name": "my rule", "predicate": "True", "action_type": "print", "action": "Hello world"}'
+        assert decoded == rule
+
+    def test_i_can_encode_decode_dynamic_concept(self):
+        sheerka, context, foo = self.init_concepts("foo", global_truth=True, create_new=True)
+        sheerka.set_attr(context, foo, "attr", "attr_value")
+        sheerka.set_property(context, foo, "prop", "prop_value", all_concepts=True)
+
+        foo_instance = sheerka.new(foo)
+        dynamic_foo = sheerka.new_dynamic(foo_instance,
+                                          "SUFFIX",
+                                          "new_name",
+                                          props={"new_prop": "value"},
+                                          attrs={"new_attr": "value"})
+
+        to_string = sheerkapickle.encode(sheerka, dynamic_foo)
+        decoded = sheerkapickle.decode(sheerka, to_string)
+
+        assert decoded == dynamic_foo
+        assert to_string == '{"_sheerka/obj": "core.concept.Concept", "concept/id": "1001-SUFFIX", "meta.name": "new_name", "meta.key": "new_name", "meta.props": {"prop": "prop_value", "new_prop": "value"}, "meta.id": "1001-SUFFIX", "values": [["new_attr", "value"]]}'