kodjo/Sheerka-Old
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initialized logging

Browse Source
This commit is contained in:
Kodjo Sossouvi
2019-11-05 19:56:00 +01:00
parent b12204360e
commit 0d2adf1b6c
10 changed files with 448 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_sheerka.py
+13 -7
View File
@@ -32,13 +32,12 @@ def init_test():
def test_root_folder_is_created_after_initialization():
return_value = Sheerka().initialize(root_folder)
assert return_value.status, "initialisation should be successful"
assert Sheerka().concept_equals(return_value.value, Sheerka().get_concept("success"))
assert os.path.exists(root_folder), "init folder should be created"
def test_lists_of_concepts_is_initialized():
Sheerka().initialize(root_folder)
assert len(Sheerka().concepts) > 1
assert len(Sheerka().concepts_cache) > 1
# def test_null_concept_are_equals():
@@ -74,18 +73,25 @@ def test_i_can_add_a_concept():
sheerka = Sheerka()
sheerka.initialize(root_folder)
res = sheerka.add_concept(concept)
concept_found = res.value
assert res.status
assert res.value == Concept(
assert concept_found == Concept(
name="a + b",
where="isinstance(a, int) and isinstance(b, int)",
pre="isinstance(a, int) and isinstance(b, int)",
post="isinstance(res, int)",
body="def func(x,y):\n return x+y\nfunc(a,b)")
assert isinstance(res.value.codes[ConceptParts.WHERE], ast.Expression)
assert isinstance(res.value.codes[ConceptParts.PRE], ast.Expression)
assert isinstance(res.value.codes[ConceptParts.POST], ast.Expression)
assert isinstance(res.value.codes[ConceptParts.BODY], ast.Module)
assert isinstance(concept_found.codes[ConceptParts.WHERE], ast.Expression)
assert isinstance(concept_found.codes[ConceptParts.PRE], ast.Expression)
assert isinstance(concept_found.codes[ConceptParts.POST], ast.Expression)
assert isinstance(concept_found.codes[ConceptParts.BODY], ast.Module)
all_props = [p.name for p in concept_found.props]
assert all_props == ["a", "b"]
assert concept_found.key == "__var__0 + __var__1"
assert concept_found.id == "100"
# def test_i_cannot_add_the_same_concept_twice():
# concept1 = DefConceptNode(name="concept")
tests/test_sheerkaDataProvider.py
+165 -164
View File
@@ -11,6 +11,7 @@ import json
from sdp.sheerkaSerializer import ObjectSerializer, BaseSerializer, Serializer, SerializerContext, PickleSerializer
tests_root = path.abspath("../build/tests")
evt_digest = "3a571cb6034ef6fc8d7fe91948d0d29728eed74de02bac7968b0e9facca2c2d7"
def read_text_file(file_name):
@@ -143,11 +144,9 @@ def test_i_can_save_and_load_an_event():
def test_i_can_add_an_string():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
event_digest = event.get_digest()
obj = "foo => bar"
entry, key = sdp.add(event, "entry", obj)
entry, key = sdp.add(evt_digest, "entry", obj)
last_commit = sdp.get_snapshot()
state = sdp.load_state(last_commit)
loaded = sdp.get(entry, key)
@@ -156,13 +155,12 @@ def test_i_can_add_an_string():
assert key is None
assert loaded == obj
assert path.exists(path.join(sdp.root, SheerkaDataProvider.EventFolder, event_digest[0:24], event_digest))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.StateFolder, last_commit[0:24], last_commit))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.HeadFile))
assert state.date is not None
assert state.parents == []
assert state.events == [event_digest]
assert state.events == [evt_digest]
assert state.data == {"entry": "foo => bar"}
assert read_text_file(path.join(sdp.root, SheerkaDataProvider.HeadFile)) == last_commit
@@ -171,9 +169,9 @@ def test_i_can_add_an_string():
def test_i_can_add_several_strings_if_allow_multiple_is_true():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", "foo")
sdp.add(Event("event"), "entry", "foo")
entry, key = sdp.add(Event("event"), "entry", "bar")
sdp.add(evt_digest, "entry", "foo")
sdp.add(evt_digest, "entry", "foo")
entry, key = sdp.add(evt_digest, "entry", "bar")
loaded = sdp.get(entry, key)
assert entry == "entry"
@@ -185,18 +183,16 @@ def test_i_cannot_add_several_strings_if_allow_multiple_is_false():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(IndexError) as index_error:
sdp.add(Event("event"), "entry", "foo", False)
sdp.add(Event("event"), "entry", "foo", False)
sdp.add(evt_digest, "entry", "foo", False)
sdp.add(evt_digest, "entry", "foo", False)
assert index_error.value.args[0] == "entry"
def test_i_can_add_an_object_with_no_key():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
event_digest = event.get_digest()
obj = ObjNoKey("a", "b")
entry, key = sdp.add(event, "entry", obj)
entry, key = sdp.add(evt_digest, "entry", obj)
last_commit = sdp.get_snapshot()
state = sdp.load_state(last_commit)
loaded = sdp.get(entry, key)
@@ -205,13 +201,12 @@ def test_i_can_add_an_object_with_no_key():
assert key is None
assert loaded == obj
assert path.exists(path.join(sdp.root, SheerkaDataProvider.EventFolder, event_digest[0:24], event_digest))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.StateFolder, last_commit[0:24], last_commit))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.HeadFile))
assert state.date is not None
assert state.parents == []
assert state.events == [event_digest]
assert state.events == [evt_digest]
assert state.data == {"entry": ObjNoKey("a", "b")}
assert read_text_file(path.join(sdp.root, SheerkaDataProvider.HeadFile)) == last_commit
@@ -220,9 +215,9 @@ def test_i_can_add_an_object_with_no_key():
def test_i_can_add_several_obj_no_key_if_allow_multiple_is_true():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjNoKey("a", "b"))
sdp.add(Event("event"), "entry", ObjNoKey("a", "b"))
entry, key = sdp.add(Event("event"), "entry", ObjNoKey("c", "d"))
sdp.add(evt_digest, "entry", ObjNoKey("a", "b"))
sdp.add(evt_digest, "entry", ObjNoKey("a", "b"))
entry, key = sdp.add(evt_digest, "entry", ObjNoKey("c", "d"))
loaded = sdp.get(entry, key)
assert entry == "entry"
@@ -234,18 +229,16 @@ def test_i_cannot_add_several_obj_no_key_if_allow_multiple_is_false():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(IndexError) as index_error:
sdp.add(Event("event"), "entry", ObjNoKey("a", "b"), False)
sdp.add(Event("event"), "entry", ObjNoKey("c", "d"), False)
sdp.add(evt_digest, "entry", ObjNoKey("a", "b"), False)
sdp.add(evt_digest, "entry", ObjNoKey("c", "d"), False)
assert index_error.value.args[0] == "entry"
def test_i_can_add_a_dict():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
event_digest = event.get_digest()
obj = {"my_key": "my_value"}
entry, key = sdp.add(event, "entry", obj)
entry, key = sdp.add(evt_digest, "entry", obj)
last_commit = sdp.get_snapshot()
state = sdp.load_state(last_commit)
loaded = sdp.get(entry, key)
@@ -257,13 +250,12 @@ def test_i_can_add_a_dict():
assert loaded == obj
assert loaded_value == "my_value"
assert path.exists(path.join(sdp.root, SheerkaDataProvider.EventFolder, event_digest[0:24], event_digest))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.StateFolder, last_commit[0:24], last_commit))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.HeadFile))
assert state.date is not None
assert state.parents == []
assert state.events == [event_digest]
assert state.events == [evt_digest]
assert state.data == {"entry": obj}
assert read_text_file(path.join(sdp.root, SheerkaDataProvider.HeadFile)) == last_commit
@@ -272,7 +264,7 @@ def test_i_can_add_a_dict():
def test_i_can_add_multiple_entries_at_once_with_dict():
sdp = SheerkaDataProvider(".sheerka")
entry, key = sdp.add(Event("event"), "entry", {"my_key1": "value1", "my_key2": "value2"})
entry, key = sdp.add(evt_digest, "entry", {"my_key1": "value1", "my_key2": "value2"})
loaded = sdp.get(entry, key)
loaded_value1 = sdp.get(entry, "my_key1")
loaded_value2 = sdp.get(entry, "my_key2")
@@ -285,11 +277,11 @@ def test_i_can_add_multiple_entries_at_once_with_dict():
def test_i_can_add_same_key_with_dict_if_allow_multiple_is_true():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", {"my_key": "my_value"})
entry, key = sdp.add(Event("event"), "entry", {"my_key": "my_value"})
sdp.add(evt_digest, "entry", {"my_key": "my_value"})
entry, key = sdp.add(evt_digest, "entry", {"my_key": "my_value"})
loaded1 = sdp.get(entry, key)
entry, key = sdp.add(Event("event"), "entry", {"my_key": "my_value2"})
entry, key = sdp.add(evt_digest, "entry", {"my_key": "my_value2"})
loaded2 = sdp.get(entry, key)
assert entry == "entry"
@@ -302,16 +294,16 @@ def test_i_cannot_add_same_key_with_dict_if_allow_multiple_is_false():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(IndexError) as index_error:
sdp.add(Event("event"), "entry", {"my_key": "my_value"}, False)
sdp.add(Event("event"), "entry", {"my_key": "my_value2"}, False)
sdp.add(evt_digest, "entry", {"my_key": "my_value"}, False)
sdp.add(evt_digest, "entry", {"my_key": "my_value2"}, False)
assert index_error.value.args[0] == "entry.my_key"
def test_i_can_add_object_with_different_key_if_allow_multiple_is_false():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", {"my_key": "a"}, False)
sdp.add(Event("event"), "entry", {"my_key2": "b"}, False)
sdp.add(evt_digest, "entry", {"my_key": "a"}, False)
sdp.add(evt_digest, "entry", {"my_key2": "b"}, False)
assert sdp.get("entry", "my_key") == "a"
assert sdp.get("entry", "my_key2") == "b"
@@ -319,13 +311,11 @@ def test_i_can_add_object_with_different_key_if_allow_multiple_is_false():
def test_i_can_add_obj_with_key():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
event_digest = event.get_digest()
obj1 = ObjWithKey("key1", "b")
obj2 = ObjSetKey("c", key="key2")
entry1, key1 = sdp.add(event, "entry", obj1) # test when key is taken from obj.get_key()
entry2, key2 = sdp.add(event, "entry2", obj2) # test when key is taken from obj.key
entry1, key1 = sdp.add(evt_digest, "entry", obj1) # test when key is taken from obj.get_key()
entry2, key2 = sdp.add(evt_digest, "entry2", obj2) # test when key is taken from obj.key
last_commit = sdp.get_snapshot()
state = sdp.load_state(last_commit)
@@ -339,13 +329,12 @@ def test_i_can_add_obj_with_key():
assert key2 == "key2"
assert loaded2 == ObjSetKey("c", key="key2")
assert path.exists(path.join(sdp.root, SheerkaDataProvider.EventFolder, event_digest[0:24], event_digest))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.StateFolder, last_commit[0:24], last_commit))
assert path.exists(path.join(sdp.root, SheerkaDataProvider.HeadFile))
assert state.date is not None
assert len(state.parents) == 1
assert state.events == [event_digest]
assert state.events == [evt_digest]
assert state.data == {"entry": {"key1": obj1}, "entry2": {"key2": obj2}}
assert read_text_file(path.join(sdp.root, SheerkaDataProvider.HeadFile)) == last_commit
@@ -354,12 +343,12 @@ def test_i_can_add_obj_with_key():
def test_i_can_add_objects_with_same_key_if_allow_multiple_is_true():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjWithKey("my_key", "b"))
entry, key = sdp.add(Event("event"), "entry", ObjSetKey("c", key="my_key"))
sdp.add(evt_digest, "entry", ObjWithKey("my_key", "b"))
entry, key = sdp.add(evt_digest, "entry", ObjSetKey("c", key="my_key"))
loaded1 = sdp.get(entry, key)
entry, key = sdp.add(Event("event"), "entry", ObjSetKey("c", key="my_key"))
sdp.add(Event("event"), "entry", ObjSetKey("c", key="my_key2")) # to prove that it does not melt everything
entry, key = sdp.add(evt_digest, "entry", ObjSetKey("c", key="my_key"))
sdp.add(evt_digest, "entry", ObjSetKey("c", key="my_key2")) # to prove that it does not melt everything
loaded2 = sdp.get(entry, key)
assert entry == "entry"
@@ -372,17 +361,17 @@ def test_i_cannot_add_object_with_same_key_if_allow_multiple_is_false():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(IndexError) as index_error:
sdp.add(Event("event"), "entry", ObjWithKey("my_key", "b"), False)
sdp.add(Event("event"), "entry", ObjSetKey("c", key="my_key"), False)
sdp.add(evt_digest, "entry", ObjWithKey("my_key", "b"), False)
sdp.add(evt_digest, "entry", ObjSetKey("c", key="my_key"), False)
assert index_error.value.args[0] == "entry.my_key"
def test_i_can_add_obj_with_key_to_a_list():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", "foo")
sdp.add(Event("event"), "entry", "bar") # entry is now a list
sdp.add(Event("event"), "entry", ObjWithKey("a", "b")) # this entry must no be taken as a object with a key
sdp.add(evt_digest, "entry", "foo")
sdp.add(evt_digest, "entry", "bar") # entry is now a list
sdp.add(evt_digest, "entry", ObjWithKey("a", "b")) # this entry must no be taken as a object with a key
loaded = sdp.get("entry")
assert loaded == ["foo", "bar", ObjWithKey("a", "b")]
@@ -392,20 +381,19 @@ def test_i_cannot_add_obj_with_no_key_when_then_entry_has_keys():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(SheerkaDataProviderError) as error:
sdp.add(Event("event"), "entry", ObjWithKey("a", "b"))
sdp.add(Event("event"), "entry", "foo")
sdp.add(evt_digest, "entry", ObjWithKey("a", "b"))
sdp.add(evt_digest, "entry", "foo")
assert error.value.obj == "foo"
def test_i_can_add_string_using_auto_generated_key():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
key_file = path.join(sdp.root, SheerkaDataProvider.KeysFile)
entry1, key1 = sdp.add_with_auto_key(event, "entry1", "foo")
entry2, key2 = sdp.add_with_auto_key(event, "entry1", "bar")
entry3, key3 = sdp.add_with_auto_key(event, "entry2", "baz")
entry1, key1 = sdp.add_with_auto_key(evt_digest, "entry1", "foo")
entry2, key2 = sdp.add_with_auto_key(evt_digest, "entry1", "bar")
entry3, key3 = sdp.add_with_auto_key(evt_digest, "entry2", "baz")
state = sdp.load_state(sdp.get_snapshot())
@@ -420,13 +408,27 @@ def test_i_can_add_string_using_auto_generated_key():
assert key3 == "1"
def test_i_can_get_and_set_key():
sdp = SheerkaDataProvider(".sheerka")
key_file = path.join(sdp.root, SheerkaDataProvider.KeysFile)
sdp.set_key("entry1", 1000)
sdp.get_next_key("entry1")
sdp.get_next_key("entry1")
sdp.get_next_key("entry1")
sdp.get_next_key("entry2")
sdp.get_next_key("entry2")
assert path.exists(key_file)
assert read_json_file(key_file) == {"entry1": 1003, "entry2": 2}
def test_i_can_add_object_using_auto_generated_key():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
key_file = path.join(sdp.root, SheerkaDataProvider.KeysFile)
entry1, key1 = sdp.add_with_auto_key(event, "entry1", ObjNoKey("a", "b"))
entry2, key2 = sdp.add_with_auto_key(event, "entry1", ObjNoKey("a", "b"))
entry1, key1 = sdp.add_with_auto_key(evt_digest, "entry1", ObjNoKey("a", "b"))
entry2, key2 = sdp.add_with_auto_key(evt_digest, "entry1", ObjNoKey("a", "b"))
state = sdp.load_state(sdp.get_snapshot())
@@ -441,11 +443,10 @@ def test_i_can_add_object_using_auto_generated_key():
def test_object_key_is_updated_when_possible_using_auto_generated_key():
sdp = SheerkaDataProvider(".sheerka")
event = Event("cmd add 'foo => bar'")
key_file = path.join(sdp.root, SheerkaDataProvider.KeysFile)
entry1, key1 = sdp.add_with_auto_key(event, "entry1", ObjSetKey("foo"))
entry2, key2 = sdp.add_with_auto_key(event, "entry1", ObjSetKey("foo"))
entry1, key1 = sdp.add_with_auto_key(evt_digest, "entry1", ObjSetKey("foo"))
entry2, key2 = sdp.add_with_auto_key(evt_digest, "entry1", ObjSetKey("foo"))
state = sdp.load_state(sdp.get_snapshot())
@@ -460,8 +461,8 @@ def test_object_key_is_updated_when_possible_using_auto_generated_key():
def test_i_can_set_objects_with_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjWithKey(1, "foo"))
entry, key = sdp.set(Event("event"), "entry", ObjWithKey(2, "foo"))
sdp.add(evt_digest, "entry", ObjWithKey(1, "foo"))
entry, key = sdp.set(evt_digest, "entry", ObjWithKey(2, "foo"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"2": ObjWithKey(2, "foo")}}
@@ -471,8 +472,8 @@ def test_i_can_set_objects_with_key():
def test_i_can_set_objects_with_no_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjNoKey(1, "foo"))
entry, key = sdp.set(Event("event"), "entry", ObjNoKey(2, "foo"))
sdp.add(evt_digest, "entry", ObjNoKey(1, "foo"))
entry, key = sdp.set(evt_digest, "entry", ObjNoKey(2, "foo"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": ObjNoKey(2, "foo")}
@@ -482,8 +483,8 @@ def test_i_can_set_objects_with_no_key():
def test_i_can_set_from_list_to_dict():
sdp = SheerkaDataProvider(".sheerka")
sdp.set(Event("event"), "entry", [ObjNoKey(1, "foo"), ObjNoKey(2, "foo")])
entry, key = sdp.set(Event("event"), "entry", {"1": ObjNoKey(1, "foo"), "2": ObjNoKey(2, "foo")})
sdp.set(evt_digest, "entry", [ObjNoKey(1, "foo"), ObjNoKey(2, "foo")])
entry, key = sdp.set(evt_digest, "entry", {"1": ObjNoKey(1, "foo"), "2": ObjNoKey(2, "foo")})
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"1": ObjNoKey(1, "foo"), "2": ObjNoKey(2, "foo")}}
@@ -494,8 +495,8 @@ def test_i_can_set_from_list_to_dict():
def test_i_can_set_using_reference():
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjWithKey)))
sdp.add(Event("event"), "entry", ObjWithKey(1, "foo"))
entry, key = sdp.set(Event("event"), "entry", ObjWithKey(2, "foo"), use_ref=True)
sdp.add(evt_digest, "entry", ObjWithKey(1, "foo"))
entry, key = sdp.set(evt_digest, "entry", ObjWithKey(2, "foo"), use_ref=True)
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"2": '##REF##:9b14e03847d73c640f54ea9b46ba62b19e5451ecd300428a225be012ad9f25f9'}}
@@ -512,10 +513,10 @@ def test_i_can_set_using_reference():
def test_i_can_add_unique():
sdp = SheerkaDataProvider(".sheerka")
sdp.add_unique(Event("event"), "entry", ObjNoKey(1, "foo"))
sdp.add_unique(Event("event"), "entry", ObjNoKey(1, "foo"))
sdp.add_unique(Event("event"), "entry", ObjNoKey(2, "bar"))
entry, key = sdp.add_unique(Event("event"), "entry", ObjNoKey(2, "bar"))
sdp.add_unique(evt_digest, "entry", ObjNoKey(1, "foo"))
sdp.add_unique(evt_digest, "entry", ObjNoKey(1, "foo"))
sdp.add_unique(evt_digest, "entry", ObjNoKey(2, "bar"))
entry, key = sdp.add_unique(evt_digest, "entry", ObjNoKey(2, "bar"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {ObjNoKey(1, "foo"), ObjNoKey(2, "bar")}}
@@ -529,7 +530,7 @@ def test_i_can_add_reference_of_an_object_with_a_key():
obj_serializer = ObjectSerializer(BaseSerializer.get_full_qualified_name(obj))
sdp.serializer.register(obj_serializer)
entry, key = sdp.add(Event("event"), "entry", obj, use_ref=True)
entry, key = sdp.add(evt_digest, "entry", obj, use_ref=True)
state = sdp.load_state(sdp.get_snapshot())
digest = state.data["entry"]["my_key"][len(SheerkaDataProvider.REF_PREFIX):]
@@ -543,15 +544,15 @@ def test_i_can_keep_state_history():
sdp = SheerkaDataProvider(".sheerka")
event1 = Event("cmd add 'foo => bar'")
event_digest1 = event1.get_digest()
event_digest1 = sdp.save_event(event1)
obj1 = "foo => bar"
sdp.add(event1, "entry1", obj1)
sdp.add(event_digest1, "entry1", obj1)
state_digest1 = sdp.get_snapshot()
event2 = Event("cmd add 'foo => baz'")
event_digest2 = event2.get_digest()
event_digest2 = sdp.save_event(event2)
obj2 = "foo => baz"
sdp.add(event2, "entry2", obj2)
sdp.add(event_digest2, "entry2", obj2)
state_digest2 = sdp.get_snapshot()
state2 = sdp.load_state(state_digest2)
@@ -578,10 +579,10 @@ def test_i_can_list_when_no_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda obj: isinstance(obj, str)))
sdp.add(Event("event"), "entry1", "foo")
sdp.add(Event("event"), "entry1", "bar")
sdp.add(Event("event"), "entry1", "baz", use_ref=True)
sdp.add(Event("event"), "entry2", "xyz")
sdp.add(evt_digest, "entry1", "foo")
sdp.add(evt_digest, "entry1", "bar")
sdp.add(evt_digest, "entry1", "baz", use_ref=True)
sdp.add(evt_digest, "entry2", "xyz")
result = sdp.list("entry1")
@@ -592,10 +593,10 @@ def test_i_can_list_when_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda obj: isinstance(obj, ObjWithKey)))
sdp.add(Event("event"), "entry1", {"1": "foo"})
sdp.add(Event("event"), "entry1", {"2": "bar"})
sdp.add(Event("event"), "entry1", ObjWithKey("3", "value"), use_ref=True)
sdp.add(Event("event"), "entry2", {"4": "xxx"})
sdp.add(evt_digest, "entry1", {"1": "foo"})
sdp.add(evt_digest, "entry1", {"2": "bar"})
sdp.add(evt_digest, "entry1", ObjWithKey("3", "value"), use_ref=True)
sdp.add(evt_digest, "entry2", {"4": "xxx"})
result = sdp.list("entry1")
@@ -604,8 +605,8 @@ def test_i_can_list_when_key():
def test_i_can_list_when_one_element():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(Event("event"), "entry2", "baz")
sdp.add(evt_digest, "entry1", "foo")
sdp.add(evt_digest, "entry2", "baz")
result = sdp.list("entry1")
@@ -614,8 +615,8 @@ def test_i_can_list_when_one_element():
def test_i_can_filter_on_key_for_dict():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", {"1": "foo"})
sdp.add(Event("event"), "entry1", {"2": "bar"})
sdp.add(evt_digest, "entry1", {"1": "foo"})
sdp.add(evt_digest, "entry1", {"2": "bar"})
result = sdp.list("entry1", lambda k, o: k == "1")
@@ -624,8 +625,8 @@ def test_i_can_filter_on_key_for_dict():
def test_i_can_filter_on_key_for_objects():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", ObjWithKey("a1", "b1"))
sdp.add(Event("event"), "entry1", ObjWithKey("a2", "b2"))
sdp.add(evt_digest, "entry1", ObjWithKey("a1", "b1"))
sdp.add(evt_digest, "entry1", ObjWithKey("a2", "b2"))
result = sdp.list("entry1", lambda k, o: k == "a1")
@@ -634,8 +635,8 @@ def test_i_can_filter_on_key_for_objects():
def test_i_can_filter_on_attribute_for_dict():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", {"1": {"a": "a1", "b": "b1"}})
sdp.add(Event("event"), "entry1", {"2": {"a": "a2", "b": "b2"}})
sdp.add(evt_digest, "entry1", {"1": {"a": "a1", "b": "b1"}})
sdp.add(evt_digest, "entry1", {"2": {"a": "a2", "b": "b2"}})
result = sdp.list("entry1", lambda k, o: o["a"] == "a2")
@@ -644,8 +645,8 @@ def test_i_can_filter_on_attribute_for_dict():
def test_i_can_filter_on_attribute_for_object():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", ObjWithKey("a1", "b1"))
sdp.add(Event("event"), "entry1", ObjWithKey("a2", "b2"))
sdp.add(evt_digest, "entry1", ObjWithKey("a1", "b1"))
sdp.add(evt_digest, "entry1", ObjWithKey("a2", "b2"))
result = sdp.list("entry1", lambda k, o: o.b == "b2")
@@ -654,8 +655,8 @@ def test_i_can_filter_on_attribute_for_object():
def test_i_can_filter_a_list():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(Event("event"), "entry1", "bar")
sdp.add(evt_digest, "entry1", "foo")
sdp.add(evt_digest, "entry1", "bar")
result = sdp.list("entry1", lambda o: o == "bar")
@@ -664,8 +665,8 @@ def test_i_can_filter_a_list():
def test_i_can_filter_a_list_of_object():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", ObjNoKey("a1", "b1"))
sdp.add(Event("event"), "entry1", ObjNoKey("a2", "b2"))
sdp.add(evt_digest, "entry1", ObjNoKey("a1", "b1"))
sdp.add(evt_digest, "entry1", ObjNoKey("a2", "b2"))
result = sdp.list("entry1", lambda o: o.b == "b1")
@@ -674,10 +675,10 @@ def test_i_can_filter_a_list_of_object():
def test_i_can_remove_all_elements():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(Event("event"), "entry1", "bar")
sdp.add(evt_digest, "entry1", "foo")
sdp.add(evt_digest, "entry1", "bar")
state_digest = sdp.remove(Event("event"), "entry1")
state_digest = sdp.remove(evt_digest, "entry1")
result = sdp.list("entry1")
assert read_text_file(path.join(sdp.root, SheerkaDataProvider.HeadFile)) == state_digest
@@ -686,10 +687,10 @@ def test_i_can_remove_all_elements():
def test_i_can_remove_a_element():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(Event("event"), "entry1", "bar")
sdp.add(evt_digest, "entry1", "foo")
sdp.add(evt_digest, "entry1", "bar")
sdp.remove(Event("event"), "entry1", lambda o: o == "foo")
sdp.remove(evt_digest, "entry1", lambda o: o == "foo")
result = sdp.list("entry1")
assert list(result) == ["bar"]
@@ -697,10 +698,10 @@ def test_i_can_remove_a_element():
def test_i_can_remove_dict_by_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", {"1": ObjNoKey("a1", "b1")})
sdp.add(Event("event"), "entry1", {"2": ObjNoKey("a2", "b2")})
sdp.add(evt_digest, "entry1", {"1": ObjNoKey("a1", "b1")})
sdp.add(evt_digest, "entry1", {"2": ObjNoKey("a2", "b2")})
sdp.remove(Event("event"), "entry1", lambda k, o: k == "2")
sdp.remove(evt_digest, "entry1", lambda k, o: k == "2")
result = sdp.list("entry1")
assert list(result) == [ObjNoKey("a1", "b1")]
@@ -708,9 +709,9 @@ def test_i_can_remove_dict_by_key():
def test_i_can_remove_when_only_one_element():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(evt_digest, "entry1", "foo")
sdp.remove(Event("event"), "entry1", lambda o: o == "foo")
sdp.remove(evt_digest, "entry1", lambda o: o == "foo")
result = sdp.list("entry1")
assert list(result) == []
@@ -719,7 +720,7 @@ def test_i_can_remove_when_only_one_element():
def test_i_cannot_remove_if_entry_does_not_exist():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(IndexError) as e:
sdp.remove(Event("event"), "entry")
sdp.remove(evt_digest, "entry")
assert str(e) == "entry"
@@ -727,17 +728,17 @@ def test_i_cannot_modify_an_entry_without_a_key():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(SheerkaDataProviderError) as error:
sdp.modify(Event("event"), "entry", None, "baz")
sdp.modify(evt_digest, "entry", None, "baz")
assert error.value.args[0] == "Key is mandatory."
def test_i_can_modify_dict_with_a_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", {"key1": "foo"})
sdp.add(Event("event"), "entry", {"key2": "bar"})
sdp.add(evt_digest, "entry", {"key1": "foo"})
sdp.add(evt_digest, "entry", {"key2": "bar"})
entry, key = sdp.modify(Event("event"), "entry", "key1", "baz")
entry, key = sdp.modify(evt_digest, "entry", "key1", "baz")
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"key1": "baz", "key2": "bar"}}
@@ -747,10 +748,10 @@ def test_i_can_modify_dict_with_a_key():
def test_i_can_modify_an_object_with_a_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjWithKey("key1", "foo"))
sdp.add(Event("event"), "entry", ObjWithKey("key2", "bar"))
sdp.add(evt_digest, "entry", ObjWithKey("key1", "foo"))
sdp.add(evt_digest, "entry", ObjWithKey("key2", "bar"))
entry, key = sdp.modify(Event("event"), "entry", "key1", ObjWithKey("key1", "baz"))
entry, key = sdp.modify(evt_digest, "entry", "key1", ObjWithKey("key1", "baz"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"key1": ObjWithKey("key1", "baz"), "key2": ObjWithKey("key2", "bar")}}
@@ -760,10 +761,10 @@ def test_i_can_modify_an_object_with_a_key():
def test_i_can_modify_an_object_while_changing_the_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjWithKey("key1", "foo"))
sdp.add(Event("event"), "entry", ObjWithKey("key2", "bar"))
sdp.add(evt_digest, "entry", ObjWithKey("key1", "foo"))
sdp.add(evt_digest, "entry", ObjWithKey("key2", "bar"))
entry, key = sdp.modify(Event("event"), "entry", "key1", ObjWithKey("key3", "baz"))
entry, key = sdp.modify(evt_digest, "entry", "key1", ObjWithKey("key3", "baz"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"key2": ObjWithKey("key2", "bar"), "key3": ObjWithKey("key3", "baz")}}
@@ -773,10 +774,10 @@ def test_i_can_modify_an_object_while_changing_the_key():
def test_i_can_modify_an_object_while_changing_the_key_to_an_existing_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjWithKey("key1", "foo"))
sdp.add(Event("event"), "entry", ObjWithKey("key2", "bar"))
sdp.add(evt_digest, "entry", ObjWithKey("key1", "foo"))
sdp.add(evt_digest, "entry", ObjWithKey("key2", "bar"))
entry, key = sdp.modify(Event("event"), "entry", "key2", ObjWithKey("key1", "bar"))
entry, key = sdp.modify(evt_digest, "entry", "key2", ObjWithKey("key1", "bar"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"key1": [ObjWithKey("key1", "foo"), ObjWithKey("key1", "bar")]}}
@@ -793,14 +794,14 @@ def test_i_can_modify_an_object_while_changing_the_key_to_an_existing_when_list(
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjDumpJson)))
sdp.add(Event("event"), "entry", ObjDumpJson("key1", "value11"))
sdp.add(Event("event"), "entry", ObjDumpJson("key1", "value12"))
sdp.add(Event("event"), "entry", ObjDumpJson("key2", "value21"))
sdp.add(Event("event"), "entry", ObjDumpJson("key2", "value22"))
sdp.add(evt_digest, "entry", ObjDumpJson("key1", "value11"))
sdp.add(evt_digest, "entry", ObjDumpJson("key1", "value12"))
sdp.add(evt_digest, "entry", ObjDumpJson("key2", "value21"))
sdp.add(evt_digest, "entry", ObjDumpJson("key2", "value22"))
new_value = ObjDumpJson("key1", "value13")
setattr(new_value, Serializer.ORIGIN, ObjDumpJson("key2", "value21").get_digest())
entry, key = sdp.modify(Event("event"), "entry", "key2", new_value)
entry, key = sdp.modify(evt_digest, "entry", "key2", new_value)
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {
@@ -820,12 +821,12 @@ def test_i_can_modify_an_object_while_changing_the_key_to_an_existing_when_nothi
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjDumpJson)))
sdp.add(Event("event"), "entry", ObjDumpJson("key2", "value21"))
sdp.add(Event("event"), "entry", ObjDumpJson("key2", "value22"))
sdp.add(evt_digest, "entry", ObjDumpJson("key2", "value21"))
sdp.add(evt_digest, "entry", ObjDumpJson("key2", "value22"))
new_value = ObjDumpJson("key1", "value13")
setattr(new_value, Serializer.ORIGIN, ObjDumpJson("key2", "value21").get_digest())
entry, key = sdp.modify(Event("event"), "entry", "key2", new_value)
entry, key = sdp.modify(evt_digest, "entry", "key2", new_value)
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {
@@ -845,13 +846,13 @@ def test_i_can_modify_an_object_while_changing_the_key_to_an_existing_when_one_i
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjDumpJson)))
sdp.add(Event("event"), "entry", ObjDumpJson("key1", "value11"))
sdp.add(Event("event"), "entry", ObjDumpJson("key2", "value21"))
sdp.add(Event("event"), "entry", ObjDumpJson("key2", "value22"))
sdp.add(evt_digest, "entry", ObjDumpJson("key1", "value11"))
sdp.add(evt_digest, "entry", ObjDumpJson("key2", "value21"))
sdp.add(evt_digest, "entry", ObjDumpJson("key2", "value22"))
new_value = ObjDumpJson("key1", "value13")
setattr(new_value, Serializer.ORIGIN, ObjDumpJson("key2", "value21").get_digest())
entry, key = sdp.modify(Event("event"), "entry", "key2", new_value)
entry, key = sdp.modify(evt_digest, "entry", "key2", new_value)
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {
@@ -865,10 +866,10 @@ def test_i_can_modify_an_object_while_changing_the_key_to_an_existing_when_one_i
def test_i_can_modify_a_ref():
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjWithKey)))
sdp.add(Event("event"), "entry", ObjWithKey("key1", "foo"))
entry, key = sdp.add(Event("event"), "entry", ObjWithKey("key2", "bar"), use_ref=True)
sdp.add(evt_digest, "entry", ObjWithKey("key1", "foo"))
entry, key = sdp.add(evt_digest, "entry", ObjWithKey("key2", "bar"), use_ref=True)
sdp.modify(Event("event"), "entry", "key2", ObjWithKey("key2", "baz"))
sdp.modify(evt_digest, "entry", "key2", ObjWithKey("key2", "baz"))
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {
"key1": ObjWithKey("key1", "foo"),
@@ -881,30 +882,30 @@ def test_i_cannot_modify_an_entry_that_does_not_exist():
sdp = SheerkaDataProvider(".sheerka")
with pytest.raises(IndexError) as e:
sdp.modify(Event("event"), "entry", "key", "foo")
sdp.modify(evt_digest, "entry", "key", "foo")
assert str(e.value) == "entry"
def test_i_cannot_modify_a_key_that_does_not_exist():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", {"1": "foo"})
sdp.add(evt_digest, "entry1", {"1": "foo"})
with pytest.raises(IndexError) as e:
sdp.modify(Event("event"), "entry1", "2", "bar")
sdp.modify(evt_digest, "entry1", "2", "bar")
assert str(e) == "entry1.2"
def test_i_cannot_modify_a_list_when_origin_is_unknown():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjWithKey("key", "value1"))
sdp.add(Event("event"), "entry", ObjWithKey("key", "value2")) # same they
sdp.add(evt_digest, "entry", ObjWithKey("key", "value1"))
sdp.add(evt_digest, "entry", ObjWithKey("key", "value2")) # same they
state = sdp.load_state(sdp.get_snapshot())
with pytest.raises(SheerkaDataProviderError) as error:
sdp.modify(Event("event"), "entry", "key", ObjWithKey("key", "value2"))
sdp.modify(evt_digest, "entry", "key", ObjWithKey("key", "value2"))
assert error.value.obj == ObjWithKey("key", "value2")
assert error.value.args[0] == "Multiple entries under 'entry.key'"
@@ -913,13 +914,13 @@ def test_i_cannot_modify_a_list_when_origin_is_unknown():
def test_i_can_modify_a_list_when_the_origin_is_known():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry", ObjDumpJson("key", "value1"))
sdp.add(Event("event"), "entry", ObjDumpJson("key", "value2")) # same they
sdp.add(evt_digest, "entry", ObjDumpJson("key", "value1"))
sdp.add(evt_digest, "entry", ObjDumpJson("key", "value2")) # same they
new_value = ObjDumpJson("key", "value3")
setattr(new_value, Serializer.ORIGIN, ObjDumpJson("key", "value1").get_digest())
sdp.modify(Event("event"), "entry", "key", new_value)
sdp.modify(evt_digest, "entry", "key", new_value)
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"key": [ObjDumpJson("key", "value3"), ObjDumpJson("key", "value2")]}}
@@ -934,13 +935,13 @@ def test_i_can_modify_a_list_when_the_origin_is_known_2():
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjDumpJson)))
sdp.add(Event("event"), "entry", ObjDumpJson("key", "value1"), use_ref=True)
sdp.add(Event("event"), "entry", ObjDumpJson("key", "value2"), use_ref=True) # same they
sdp.add(evt_digest, "entry", ObjDumpJson("key", "value1"), use_ref=True)
sdp.add(evt_digest, "entry", ObjDumpJson("key", "value2"), use_ref=True) # same they
objs = sdp.get("entry", "key") # origin is automatically set to the loaded objects
objs[0].value = "value3"
sdp.modify(Event("event"), "entry", "key", objs[0])
sdp.modify(evt_digest, "entry", "key", objs[0])
state = sdp.load_state(sdp.get_snapshot())
assert state.data == {"entry": {"key": [
@@ -955,8 +956,8 @@ def test_i_can_modify_a_list_when_the_origin_is_known_2():
def test_i_can_get_the_entire_entry():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(Event("event"), "entry1", "bar")
sdp.add(evt_digest, "entry1", "foo")
sdp.add(evt_digest, "entry1", "bar")
result = sdp.get("entry1")
result_safe = sdp.get_safe("entry1")
@@ -967,7 +968,7 @@ def test_i_can_get_the_entire_entry():
def test_i_can_get_an_entry_with_on_object():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", "foo")
sdp.add(evt_digest, "entry1", "foo")
result = sdp.get("entry1")
result_safe = sdp.get_safe("entry1")
@@ -978,8 +979,8 @@ def test_i_can_get_an_entry_with_on_object():
def test_i_can_get_an_entry_by_key():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", {"1": "foo"})
sdp.add(Event("event"), "entry1", {"2": "bar"})
sdp.add(evt_digest, "entry1", {"1": "foo"})
sdp.add(evt_digest, "entry1", {"2": "bar"})
result = sdp.get("entry1", "2")
result_safe = sdp.get_safe("entry1", "2")
@@ -993,7 +994,7 @@ def test_i_can_get_object_save_by_reference():
obj = ObjDumpJson("my_key", "value1")
sdp.serializer.register(ObjectSerializer(BaseSerializer.get_full_qualified_name(obj)))
entry, key = sdp.add(Event("event"), "entry", obj, use_ref=True)
entry, key = sdp.add(evt_digest, "entry", obj, use_ref=True)
loaded = sdp.get(entry, key)
assert loaded == obj
@@ -1003,8 +1004,8 @@ def test_i_can_get_objects_from_list_when_saved_by_reference():
sdp = SheerkaDataProvider(".sheerka")
sdp.serializer.register(PickleSerializer(lambda o: isinstance(o, ObjDumpJson)))
sdp.add(Event("event"), "entry", ObjDumpJson("key", "value1"), use_ref=True)
sdp.add(Event("event"), "entry", ObjDumpJson("key", "value2"), use_ref=True) # same they
sdp.add(evt_digest, "entry", ObjDumpJson("key", "value1"), use_ref=True)
sdp.add(evt_digest, "entry", ObjDumpJson("key", "value2"), use_ref=True) # same they
objs = sdp.get("entry", "key")
@@ -1023,7 +1024,7 @@ def test_i_cannot_get_an_entry_that_does_not_exist():
def test_i_cannot_get_a_key_that_does_not_exist():
sdp = SheerkaDataProvider(".sheerka")
sdp.add(Event("event"), "entry1", {"1": "foo"})
sdp.add(evt_digest, "entry1", {"1": "foo"})
assert sdp.get_safe("entry1", "2") is None
with pytest.raises(IndexError) as e:
@@ -1090,7 +1091,7 @@ def test_i_can_test_than_an_entry_exits():
sdp = SheerkaDataProvider(".sheerka")
assert not sdp.exists("entry")
sdp.add(Event("event"), "entry", "value")
sdp.add(evt_digest, "entry", "value")
assert sdp.exists("entry")
@@ -1099,7 +1100,7 @@ def test_i_can_save_and_load_object_ref_with_history():
obj = ObjDumpJson("my_key", "value1")
sdp.serializer.register(ObjectSerializer(BaseSerializer.get_full_qualified_name(obj)))
entry, key = sdp.add(Event("event"), "entry", obj, use_ref=True)
entry, key = sdp.add(evt_digest, "entry", obj, use_ref=True)
loaded = sdp.get(entry, key)
history = getattr(loaded, Serializer.HISTORY)
@@ -1118,7 +1119,7 @@ def test_i_can_save_and_load_object_ref_with_history():
previous_modification_time = history[Serializer.MODIFICATION_DATE]
previous_parents = history[Serializer.PARENTS]
sdp.modify(Event("event"), "entry", key, loaded)
sdp.modify(evt_digest, "entry", key, loaded)
loaded = sdp.get(entry, key)
history = getattr(loaded, Serializer.HISTORY)
@@ -1129,7 +1130,7 @@ def test_i_can_save_and_load_object_ref_with_history():
previous_digest = loaded.get_digest()
loaded.value = "value2"
sdp.modify(Event("event"), "entry", key, loaded)
sdp.modify(evt_digest, "entry", key, loaded)
loaded2 = sdp.get(entry, key)
history2 = getattr(loaded2, Serializer.HISTORY)