def test_update_struct_as_nested_struct(self):
d = ObservedDict(
{"nested": {
"a": 1
}},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
old_struct = d._struct["nested"]
d["nested"] = ObservedDict({"b": 2})
assert pre_callback.call_args == [(d, ObservedOperation.Update,
["nested"], {
"a": 1
}, {
"b": 2
})]
assert post_callback.call_args == [(d, ObservedOperation.Update,
["nested"], {
"a": 1
}, {
"b": 2
})]
assert d == {"nested": {"b": 2}}
assert d["nested"]._parent == d
assert d["nested"]._reference_in_parent == "nested"
assert old_struct._parent is None
assert old_struct._reference_in_parent is None
def test_comparison(self):
d = ObservedDict({"a": {"b": 2}})
assert d == ObservedDict({"a": {"b": 2}})
assert d["a"] == ObservedDict({"b": 2})
assert d == ObservedDict({"a": ObservedDict({"b": 2})})
assert d == {"a": {"b": 2}}
assert d["a"] == {"b": 2}
def test_instantiation_with_another_observed_struct_type(self):
d = ObservedDict({"a": [1, 2]})
assert d == {"a": [1, 2]}
assert d["a"] == [1, 2]
assert isinstance(d["a"], ObservedList)
assert d["a"]._parent is d
assert d["a"]._reference_in_parent == "a"
def test_instantiation_with_nested_dict(self):
d = ObservedDict({"a": {"b": 2}})
assert d == {"a": {"b": 2}}
assert d["a"] == {"b": 2}
assert d["a"]["b"] == 2
assert isinstance(d["a"], ObservedDict)
assert d["a"]._parent is d
assert d["a"]._reference_in_parent == "a"
def test_add_struct_as_nested_struct(self):
d = ObservedDict(pre_callbacks=[pre_callback],
post_callbacks=[post_callback])
d["nested"] = ObservedDict({"a": 1})
assert pre_callback.call_args == [(d, ObservedOperation.Add,
["nested"], None, {
"a": 1
})]
assert post_callback.call_args == [(d, ObservedOperation.Add,
["nested"], None, {
"a": 1
})]
assert d["nested"] == {"a": 1}
assert d["nested"]._parent == d
assert d["nested"]._reference_in_parent == "nested"
def test_add(self):
d = ObservedDict(pre_callbacks=[pre_callback],
post_callbacks=[post_callback])
d["a"] = 1
assert pre_callback.call_args == [(d, ObservedOperation.Add, ["a"],
None, 1)]
assert post_callback.call_args == [(d, ObservedOperation.Add,
["a"], None, 1)]
assert d == {"a": 1}
def test_access(self):
d = ObservedDict(
{"a": 1},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
assert d["a"] == 1
assert pre_callback.call_args == [(d, ObservedOperation.Access,
["a"], None, None)]
assert post_callback.call_args == [(d, ObservedOperation.Access,
["a"], None, None)]
assert d == {"a": 1}
def test_delete(self):
d = ObservedDict(
{"a": 1},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
del d["a"]
assert pre_callback.call_args == [(d, ObservedOperation.Remove,
["a"], 1, None)]
assert post_callback.call_args == [(d, ObservedOperation.Remove,
["a"], 1, None)]
assert d == {}
def test_update(self):
d = ObservedDict(
{"a": 1},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
d["a"] = 2
assert pre_callback.call_args == [(d, ObservedOperation.Update,
["a"], 1, 2)]
assert post_callback.call_args == [(d, ObservedOperation.Update,
["a"], 1, 2)]
assert d == {"a": 2}
def test_access_to_nested_struct(self):
d = ObservedDict(
{"nested": {
"a": 1
}},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
assert d["nested"] == {"a": 1}
assert pre_callback.call_args == [(d, ObservedOperation.Access,
["nested"], None, None)]
assert post_callback.call_args == [(d, ObservedOperation.Access,
["nested"], None, None)]
assert d == {"nested": {"a": 1}}
def test_add_scalar_to_nested_struct(self):
d = ObservedDict(
{"nested": {}},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
d["nested"]["a"] = 1
assert pre_callback.call_args == [
(d, ObservedOperation.Access, ["nested"], None, None),
(d, ObservedOperation.Add, ["nested", "a"], None, 1),
]
assert post_callback.call_args == [
(d, ObservedOperation.Access, ["nested"], None, None),
(d, ObservedOperation.Add, ["nested", "a"], None, 1),
]
assert d == {"nested": {"a": 1}}
def test_list_in_dict(self):
d = ObservedDict(
{"a": [1]},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
assert d["a"][0] == 1
assert pre_callback.call_args == [
(d, ObservedOperation.Access, ["a"], None, None),
(d, ObservedOperation.Access, ["a", 0], None, None),
]
assert post_callback.call_args == [
(d, ObservedOperation.Access, ["a"], None, None),
(d, ObservedOperation.Access, ["a", 0], None, None),
]
assert d == {"a": [1]}
def test_update_scalar_in_nested_struct(self):
d = ObservedDict(
{"nested": {
"a": 1
}},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
d["nested"]["a"] = 2
assert pre_callback.call_args == [
(d, ObservedOperation.Access, ["nested"], None, None),
(d, ObservedOperation.Update, ["nested", "a"], 1, 2),
]
assert post_callback.call_args == [
(d, ObservedOperation.Access, ["nested"], None, None),
(d, ObservedOperation.Update, ["nested", "a"], 1, 2),
]
assert d == {"nested": {"a": 2}}
def test_delete_scalar_from_nested_struct(self):
d = ObservedDict(
{"nested": {
"a": 1
}},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
del d["nested"]["a"]
assert pre_callback.call_args == [
(d, ObservedOperation.Access, ["nested"], None, None),
(d, ObservedOperation.Remove, ["nested", "a"], 1, None),
]
assert post_callback.call_args == [
(d, ObservedOperation.Access, ["nested"], None, None),
(d, ObservedOperation.Remove, ["nested", "a"], 1, None),
]
assert d == {"nested": {}}
def test_delete_nested_struct(self):
d = ObservedDict(
{"nested": {
"a": 1
}},
pre_callbacks=[pre_callback],
post_callbacks=[post_callback],
)
old_struct = d._struct["nested"]
del d["nested"]
assert pre_callback.call_args == [(d, ObservedOperation.Remove,
["nested"], {
"a": 1
}, None)]
assert post_callback.call_args == [(d, ObservedOperation.Remove,
["nested"], {
"a": 1
}, None)]
assert d == {}
assert old_struct._parent is None
assert old_struct._reference_in_parent is None
def test_popitem_from_empty_dict(self):
d = ObservedDict()
with pytest.raises(KeyError):
d.popitem()
def d(self):
return ObservedDict({"a": 1, "b": 2})
def test_get_item_for_reference():
d = ObservedDict({"a": [1]})
assert get_item_for_reference(d, ["a", 0]) == 1
def test_instantiation_without_arguments(self):
d = ObservedDict()
assert d == {}
def test_instantiation_with_another_observed_dict(self):
d = ObservedDict(ObservedDict({"a": 1}))
assert d == {"a": 1}
assert isinstance(d._struct, dict)
def test_instantiation_with_dict(self):
d = ObservedDict({"a": 1})
assert d == {"a": 1}
assert d["a"] == 1
def test_instantiation_with_empty_dict(self):
d = ObservedDict({})
assert d == {}
