def test_large_dict(sheraf_database): with sheraf.connection(commit=True) as c: c.root.dict = sheraf.types.LargeDict() for i in range(100): c.root.dict[i] = str(i) with sheraf.connection() as c: assert c.root.dict[50] == "50" with pytest.raises(KeyError): c.root.dict[-1] assert 25 in c.root.dict assert 100 == len(c.root.dict) with sheraf.connection() as c: assert list(c.root.dict[98:]) == ["98", "99"] assert list(c.root.dict[12:14]) == ["12", "13", "14"] assert list(c.root.dict[:4]) == ["0", "1", "2", "3", "4"] assert list(c.root.dict[:]) == [str(i) for i in range(100)] with sheraf.connection() as c: assert list(c.root.dict[98::-1]) == ["99", "98"] assert list(c.root.dict[:3:-1]) == ["3", "2", "1", "0"] assert list(c.root.dict[10:12:-1]) == ["12", "11", "10"] assert list(c.root.dict[90:94:2]) == ["90", "92", "94"]
def test_threading(self, sheraf_database): with sheraf.connection(commit=True) as c: c.root.list = sheraf.types.LargeList() class Writer(threading.Thread): def __init__(self, name): super().__init__() self.failed = False self.name = name def run(self): try: with sheraf.connection() as c: for i in range(LENGTH): sheraf.attempt( lambda: c.root.list.append(self.name + str(i)), attempts=10) except BaseException as ex: self.failed = ex writers = [Writer(i) for i in THREADS] [w.start() for w in writers] [w.join() for w in writers] for w in (w for w in writers if w.failed): assert not w.failed with sheraf.connection() as c: assert len(c.root.list) == len(THREADS) * LENGTH for name in THREADS: for i in range(LENGTH): assert str(name) + str(i) in c.root.list
def test_edit_a_not_single_instance_after_set_index_in_one_of_two_attributes( sheraf_database, ): class Model(tests.UUIDAutoModel): my_simple_attribute = sheraf.SimpleAttribute() my_other_attribute = sheraf.SimpleAttribute() with sheraf.connection(commit=True): m = Model.create( my_simple_attribute="foo_not_indexed", my_other_attribute="other1" ) # Having more than one instance must prevent indexation Model.create( my_simple_attribute="foo_not_indexed2", my_other_attribute="other2" ) class Model(tests.UUIDAutoModel): my_simple_attribute = sheraf.SimpleAttribute().index() with sheraf.connection(commit=True): m = Model.read(m.id) with warnings.catch_warnings(record=True) as warning_messages: m.my_other_attribute = "new_other1" m.my_simple_attribute = "bar_still_not_indexed" assert "my_simple_attribute will not be indexed." in str( warning_messages[0].message ) with sheraf.connection() as conn: assert "my_simple_attribute" not in conn.root()["model"] assert "my_other_attribute" not in conn.root()["model"]
def test_healthcheck_attributes_index_non_primitive_with_key( sheraf_database, capsys): from .fixture1 import Model3k, DummyModel with sheraf.connection(commit=True) as conn: Model3k.create(simple="simple1", obj_indexed=DummyModel.create(v="str1")) Model3k.create(simple="simple2", obj_indexed=DummyModel.create(v="str2")) index_table = conn.root()["model3k_table"]["obj"] del index_table["str1"] with sheraf.connection() as conn: assert "str1" not in conn.root()["model3k_table"]["obj"] assert "str2" in conn.root()["model3k_table"]["obj"] health = check_health(fixture1, instance_checks=[], attribute_checks=["index" ])["check_attributes_index"] assert { "obj": { "ok": 1, "ko": 1 } } == health["tests.health.fixture1.Model3k"] print_health(fixture1) stdout = capsys.readouterr().out assert re.search(r"tests.health.fixture1.Model3k[^\n]*1[^\n]*1", stdout)
def test_healthcheck_attributes_index_when_instance_deleted( sheraf_database, capsys): from .fixture1 import Model2unique with sheraf.connection(commit=True) as conn: Model2unique.create(simple="simple1", str_indexed="str1") Model2unique.create(simple="simple1", str_indexed="str2") m = Model2unique.create(simple="simple2", str_indexed="str3") mmapping = sheraf.types.SmallDict(m.mapping) m.delete() index_table = conn.root()["model2unique_table"]["str_indexed"] index_table["str3"] = mmapping with sheraf.connection() as conn: kwargs = dict(model_checks=["index"], instance_checks=[], attribute_checks=[]) assert "str1" in conn.root()["model2unique_table"]["str_indexed"] assert "str2" in conn.root()["model2unique_table"]["str_indexed"] health = check_health(fixture1, **kwargs)["check_model_index"] assert { "str_indexed": { "ok": 2, "ko": 1 } } == health["tests.health.fixture1.Model2unique"] print_health(fixture1, **kwargs) stdout = capsys.readouterr().out assert re.search(r"tests.health.fixture1.Model2unique[^\n]*1[^\n]*2", stdout)
def test_multiple_keys_index_update(sheraf_database, Model): with sheraf.connection(commit=True): mfoo = Model.create(my_attribute="bar") with sheraf.connection(commit=True): mfoo = Model.read(mfoo.id) mfoo.my_attribute = "foo" with sheraf.connection() as conn: index_table_key_1 = conn.root()[Model.table]["key_1"] index_table_key_2 = conn.root()[Model.table]["key_2"] assert {"foo"} == set(index_table_key_1) assert {mfoo.raw_identifier: mfoo.mapping} == dict(index_table_key_1["foo"]) assert {"foo"} == set(index_table_key_2) assert {mfoo.raw_identifier: mfoo.mapping} == dict(index_table_key_2["foo"]) with pytest.raises(sheraf.exceptions.MultipleIndexException): Model.read(key_1="foo") assert [mfoo] == list(Model.read_these(key_1=["foo"])) with pytest.raises(sheraf.exceptions.MultipleIndexException): Model.read(key_2="foo") assert [mfoo] == list(Model.read_these(key_2=["foo"])) # Model._read_multiple_index = mock.MagicMock( # side_effect=Model._read_multiple_index # ) assert [mfoo] == Model.filter(key_1="foo") # Model._read_multiple_index.assert_has_calls( # [mock.call("foo", "key_1")] # ) assert [mfoo] == Model.filter(key_2="foo")
def test_common_index_different_values_methods(sheraf_database, Model): assert Model.indexes["theindex"].details.values_funcs[Model.lower] == [ [Model.attributes["foo"]] ] assert Model.indexes["theindex"].details.values_funcs[Model.upper] == [ [Model.attributes["bar"]] ] assert Model.indexes["theindex"].details.values_funcs[None] == [] assert Model.indexes["theindex"].details.default_values_func is None assert Model.indexes["theindex"].details.search_func is None with sheraf.connection(commit=True) as conn: m = Model.create(foo="FOo", bar="bAr") with sheraf.connection() as conn: index_table = conn.root()[Model.table]["theindex"] assert {"foo", "BAR"} == set(index_table) assert {m.raw_identifier: m.mapping} == dict(index_table["foo"]) assert {m.raw_identifier: m.mapping} == dict(index_table["BAR"]) assert [m] == list(Model.read_these(theindex=["foo"])) assert [m] == list(Model.read_these(theindex=["BAR"])) assert [m] == Model.search(theindex="foo") assert [m] == Model.search(theindex="BAR") assert [] == Model.search(theindex="FOo") assert [] == Model.search(theindex="bAr")
def test_generic_nominal_case(sheraf_database): class Model(tests.UUIDAutoModel): submodel = sheraf.ModelAttribute((Submodel1, Submodel2)) with sheraf.connection(commit=True): s1 = Submodel1.create(name="foo") s2 = Submodel2.create(name="bar") m1 = Model.create(submodel=s1) m2 = Model.create(submodel=s2) assert (Submodel1.table, s1.id) == m1.mapping["submodel"] assert (Submodel2.table, s2.id) == m2.mapping["submodel"] assert "foo" == m1.submodel.name assert "bar" == m2.submodel.name with sheraf.connection(): m1 = Model.read(m1.id) m2 = Model.read(m2.id) assert isinstance(m1.submodel, Submodel1) assert isinstance(m2.submodel, Submodel2) assert "foo" == m1.submodel.name assert "bar" == m2.submodel.name
def test_update_no_addition(sheraf_database): class Model(tests.UUIDAutoModel): inlines = sheraf.LargeDictAttribute( sheraf.InlineModelAttribute(DictInlineModel)) with sheraf.connection(commit=True): model = Model.create(inlines={"a": {"name": "a"}}) with sheraf.connection(commit=True): model.edit(value={"inlines": {"b": {"name": "b"}}}, addition=True) assert isinstance(model.mapping["inlines"], sheraf.types.LargeDict) assert isinstance(model.inlines["b"], DictInlineModel) assert isinstance(model.inlines["b"].mapping, sheraf.types.SmallDict) assert "a" == model.inlines["a"].name assert "b" == model.inlines["b"].name with sheraf.connection(): model = Model.read(model.id) assert isinstance(model.mapping["inlines"], sheraf.types.LargeDict) assert isinstance(model.inlines["b"], DictInlineModel) assert isinstance(model.inlines["b"].mapping, sheraf.types.SmallDict) assert "a" == model.inlines["a"].name assert "b" == model.inlines["b"].name
def test_update_edition(sheraf_database, attribute, list_type): class Model(tests.UUIDAutoModel): inlines = attribute(sheraf.InlineModelAttribute(ListInlineModel)) with sheraf.connection(commit=True): model = Model.create(inlines=[{"name": "c"}, {"name": "c"}]) with sheraf.connection(commit=True): model.edit(value={"inlines": [{ "name": "a" }, { "name": "b" }]}, edition=True) assert isinstance(model.mapping["inlines"], list_type) assert isinstance(model.inlines[0], ListInlineModel) assert isinstance(model.inlines[1], ListInlineModel) x, y = list(model.inlines) assert "a" == x.name assert "b" == y.name with sheraf.connection(): model = Model.read(model.id) assert isinstance(model.mapping["inlines"], list_type) assert isinstance(model.inlines[0], ListInlineModel) assert isinstance(model.inlines[1], ListInlineModel) x, y = list(model.inlines) assert "a" == x.name assert "b" == y.name
def test_update_no_addition(sheraf_database, attribute, list_type): class Model(tests.UUIDAutoModel): inlines = attribute(sheraf.InlineModelAttribute(ListInlineModel)) with sheraf.connection(commit=True): model = Model.create(inlines=[{"name": "a"}]) with sheraf.connection(commit=True): model.edit(value={"inlines": [{ "name": "a" }, { "name": "b" }]}, addition=False) assert isinstance(model.mapping["inlines"], list_type) assert "a" == model.inlines[0].name assert len(model.inlines) == 1 with sheraf.connection(): model = Model.read(model.id) assert isinstance(model.mapping["inlines"], list_type) assert "a" == model.inlines[0].name assert len(model.inlines) == 1
def test_update_edition(sheraf_database): class Model(tests.UUIDAutoModel): models = sheraf.LargeDictAttribute(sheraf.ModelAttribute(AModel)) with sheraf.connection(commit=True): model = Model.create(models={"a": {"name": "c"}, "b": {"name": "c"}}) last_sub_id = model.models["a"].id with sheraf.connection(commit=True): model.edit(value={"models": {"a": {"name": "a"}, "b": {"name": "b"}}}) assert isinstance(model.models["a"], AModel) assert isinstance(model.models["b"], AModel) assert "a" == model.models["a"].name assert "b" == model.models["b"].name assert last_sub_id == model.models["a"].id with sheraf.connection(): model = Model.read(model.id) assert isinstance(model.models["a"], AModel) assert isinstance(model.models["b"], AModel) assert "a" == model.models["a"].name assert "b" == model.models["b"].name assert last_sub_id == model.models["a"].id
def test_update_replacement(sheraf_database): class Model(tests.UUIDAutoModel): models = sheraf.LargeDictAttribute(sheraf.ModelAttribute(AModel)) with sheraf.connection(commit=True): model = Model.create(models={"a": {"name": "c"}, "b": {"name": "c"}}) last_sub_id = model.models["a"].id with sheraf.connection(commit=True): old_submapping = model.models["a"].mapping model.edit( value={"models": {"a": {"name": "a"}, "b": {"name": "b"}}}, edition=True, replacement=True, ) new_submapping = model.models["a"].mapping assert isinstance(model.mapping["models"], sheraf.types.LargeDict) assert isinstance(model.models["a"], AModel) assert isinstance(new_submapping, sheraf.types.SmallDict) assert "a" == model.models["a"].name assert "b" == model.models["b"].name assert old_submapping is not new_submapping assert last_sub_id != model.models["a"].id with sheraf.connection(): model = Model.read(model.id) assert isinstance(model.mapping["models"], sheraf.types.LargeDict) assert isinstance(model.models["a"], AModel) assert isinstance(new_submapping, sheraf.types.SmallDict) assert "a" == model.models["a"].name assert "b" == model.models["b"].name assert old_submapping is not new_submapping assert last_sub_id != model.models["a"].id
def test_rebuild_all_models_one_index(sheraf_zeo_database): with sheraf.connection(commit=True) as conn: bar = CliModel.create(foo="bar", boo="bar") baz = CliModel.create(foo="baz", boo="baz") del conn.root()[CliModel.table]["foo"] del conn.root()[CliModel.table]["boo"] runner = CliRunner() result = runner.invoke( cli, [ f"{sheraf_zeo_database.uri}&database_name=cli", "rebuild", "tests.test_cli", "--indexes", "foo", ], ) assert result.exit_code == 0, result.output with sheraf.connection() as conn: assert "foo" in conn.root()[CliModel.table] assert "boo" not in conn.root()[CliModel.table] assert bar in CliModel.search(foo="bar") assert baz in CliModel.search(foo="baz")
def test_common_index_complex(sheraf_database): class Model(tests.IntAutoModel): foo = sheraf.SimpleAttribute() bar = sheraf.SimpleAttribute() theindex = sheraf.Index(foo, bar) @theindex.values def values(self, value): return {value.lower(), value.upper()} with sheraf.connection(commit=True) as conn: m = Model.create(foo="foo", bar="bar") assert {"foo", "bar", "FOO", "BAR"} == set(conn.root()[Model.table]["theindex"]) m.bar = "baz" assert {"foo", "baz", "FOO", "BAZ"} == set(conn.root()[Model.table]["theindex"]) with sheraf.connection(commit=True) as conn: m = Model.read(m.id) assert {"foo", "baz", "FOO", "BAZ"} == set(conn.root()[Model.table]["theindex"]) m.foo = "OOF" assert {"oof", "baz", "OOF", "BAZ"} == set(conn.root()[Model.table]["theindex"]) del m.foo assert {"baz", "BAZ"} == set(conn.root()[Model.table]["theindex"])
def test_datetime_lastupdate_datetime(sheraf_database): sheraf_database.reset() class Model(tests.UUIDAutoModel): pass with libfaketime.fake_time("2014-08-04 02:00:00") as fk: with sheraf.connection(commit=True) as conn: m = Model.create() fk.tick() assert m.last_update_datetime() is None conn.transaction_manager.commit() assert datetime.datetime(2014, 8, 4, 2, 0, 1) == m.last_update_datetime() with sheraf.connection(): m = Model.read(m.id) assert datetime.datetime(2014, 8, 4, 2, 0, 1) == m.last_update_datetime() with libfaketime.fake_time("2014-08-04 08:00:00") as fk: with sheraf.connection(commit=True) as conn: m = Model.read(m.id) m.save() fk.tick() assert datetime.datetime(2014, 8, 4, 2, 0, 1) == m.last_update_datetime() conn.transaction_manager.commit() assert datetime.datetime(2014, 8, 4, 8, 0, 1) == m.last_update_datetime()
def test_index_table_rebuild(sheraf_database): class Model(tests.UUIDAutoModel): foo = sheraf.SimpleAttribute() bar = sheraf.SimpleAttribute() with sheraf.connection(commit=True): Model.create(foo="bar", bar="bar") Model.create(foo="baz", bar="bor") class Model(tests.UUIDAutoModel): foo = sheraf.SimpleAttribute().index() bar = sheraf.SimpleAttribute().index() with sheraf.connection(commit=True): with warnings.catch_warnings(record=True) as warns: Model.create(foo="foobar", bar="bur") assert warns[0].category is sheraf.exceptions.IndexationWarning assert warns[1].category is sheraf.exceptions.IndexationWarning with sheraf.connection(commit=True): Model.index_table_rebuild() with sheraf.connection(commit=True): assert 3 == Model.count() with warnings.catch_warnings(record=True) as warns: Model.create(foo="foobar", bar="boo") assert not warns
def test_time_attribute(sheraf_database): class Model(tests.UUIDAutoModel): time = sheraf.TimeAttribute() with sheraf.connection(commit=True): m = Model.create() assert m.time is None m.time = datetime.time(12, 13, 14) assert m.mapping["time"] == 43994000000 assert m.time == datetime.time(12, 13, 14) with sheraf.connection(): m = Model.read(m.id) m.time = datetime.time(12, 13, 14) assert m.mapping["time"] == 43994000000 assert m.time == datetime.time(12, 13, 14) with sheraf.connection(commit=True): m = Model.read(m.id) m.time = None assert m.time is None assert m.mapping["time"] == -1 with sheraf.connection(): m = Model.read(m.id) assert m.time is None assert m.mapping["time"] == -1
def test_custom_indexation_method(sheraf_database, Model): with sheraf.connection(commit=True): m = Model.create(foo="FOO", bar="BAR") func = Model.indexes["foo"].details.default_values_func assert func is not None assert {"foo"} == Model.indexes["foo"].details.get_values( m, [Model.attributes["foo"]], func ) with sheraf.connection() as conn: index_table = conn.root()[Model.table]["foo"] assert {"foo"} == set(index_table) assert m.mapping == index_table["foo"] assert [m] == list(Model.filter(foo="foo")) assert [] == list(Model.filter(foo="FOO")) assert [m] == list(Model.filter(foo="foo", bar="BAR")) assert [] == list(Model.filter(foo="foo", bar="bar")) assert [m] == list(Model.search(foo="foo")) assert [m] == list(Model.search(foo="FOO")) assert [m] == list(Model.search(foo="foo", bar="BAR")) assert [m] == list(Model.search(foo="FOO", bar="BAR")) assert [] == list(Model.search(foo="foo", bar="bar")) assert [] == list(Model.search(foo="FOO", bar="bar")) with sheraf.connection(): with pytest.raises(sheraf.exceptions.UniqueIndexException): Model.create(foo="FOO")
def test_date_attribute(sheraf_database): class Model(tests.UUIDAutoModel): date = sheraf.DateAttribute() with sheraf.connection(commit=True): m = Model.create() assert m.date is None m.date = datetime.date(1971, 1, 1) assert m.mapping["date"] == 365 assert m.date == datetime.date(1971, 1, 1) with sheraf.connection(): m = Model.read(m.id) m.date = datetime.date(1971, 1, 1) assert m.mapping["date"] == 365 assert m.date == datetime.date(1971, 1, 1) with sheraf.connection(commit=True): m = Model.read(m.id) m.date = None assert m.date is None assert m.mapping["date"] == -1 with sheraf.connection(): m = Model.read(m.id) assert m.date is None assert m.mapping["date"] == -1
def test_healthcheck_attributes_index_with_key(sheraf_database, capsys): from .fixture1 import Model2kunique with sheraf.connection(commit=True) as conn: Model2kunique.create(simple="simple1", str_indexed="str1") Model2kunique.create(simple="simple2", str_indexed="str2") index_table = conn.root()["model2kunique_table"]["str"] del index_table["str1"] with sheraf.connection() as conn: kwargs = dict(instance_checks=[], attribute_checks=["index"]) assert "str1" not in conn.root()["model2kunique_table"]["str"] assert "str2" in conn.root()["model2kunique_table"]["str"] health = check_health(fixture1, **kwargs)["check_attributes_index"] assert { "str": { "ok": 1, "ko": 1 } } == health["tests.health.fixture1.Model2kunique"] print_health(fixture1, **kwargs) stdout = capsys.readouterr().out assert re.search(r"tests.health.fixture1.Model2kunique[^\n]*1[^\n]*1", stdout)
def test_make_id(sheraf_database, db2): class Model(tests.UUIDAutoModel): pass class ModelWithProposeId(Model): table = "modelwithproposeid" id = sheraf.IntegerAttribute(default=lambda m: m.count()).index(primary=True) with sheraf.connection(commit=True): m0 = ModelWithProposeId.create() m1 = ModelWithProposeId.create() assert m0.id == 0 assert m1.id == 1 class Model(tests.UUIDAutoModel): database_name = "db2" class ModelWithProposeId(Model): table = "modelwithproposeid" id = sheraf.IntegerAttribute(default=lambda m: m.count()).index(primary=True) with sheraf.connection() as conn: root1 = conn.root() root2 = conn.get_connection("db2").root() m2 = ModelWithProposeId.create() m3 = ModelWithProposeId.create() assert m2.id == 2 assert m3.id == 3 assert root1["modelwithproposeid"]["id"][m1.id] is m1.mapping assert root2["modelwithproposeid"]["id"][m2.id] is m2.mapping
def test_multiple_healthcheck_attributes_index_when_instance_deleted( sheraf_database, capsys): from .fixture1 import Model2 with sheraf.connection(commit=True) as conn: Model2.create(simple="simple1", str_indexed="str1") index_table = conn.root()["model2_table"]["str_indexed"] m21 = Model2.create(simple="simple21", str_indexed="str2") m22 = Model2.create(simple="simple22", str_indexed="str2") m21_deletedmapping = sheraf.types.SmallDict(m21.mapping) assert dict(index_table["str2"]) == { m21.raw_identifier: m21.mapping, m22.raw_identifier: m22.mapping, } m21.delete() index_table["str2"] = { m21.raw_identifier: m21_deletedmapping, m22.raw_identifier: m22.mapping, } with sheraf.connection() as conn: kwargs = dict(model_checks=["index"], instance_checks=[], attribute_checks=[]) assert "str1" in conn.root()["model2_table"]["str_indexed"] assert "str2" in conn.root()["model2_table"]["str_indexed"] health = check_health(fixture1, **kwargs)["check_model_index"] assert { "str_indexed": { "ok": 1, "ko": 1 } } == health["tests.health.fixture1.Model2"]
def test_model_create_in_default_connection(sheraf_database, db2): class Model(tests.UUIDAutoModel): pass class MyDefaultModel(tests.UUIDAutoModel): database_name = "unnamed" class MyDB2Model(tests.UUIDAutoModel): database_name = "db2" with sheraf.connection(commit=True) as connection: rootd = connection.root() m = Model.create() md = MyDefaultModel.create() m2 = MyDB2Model.create() with sheraf.connection() as connection: rootd = connection.root() root2 = connection.get_connection("db2").root() assert m.id in rootd[Model.table]["id"] assert md.id in rootd[MyDefaultModel.table]["id"] assert m2.id in root2[MyDB2Model.table]["id"] assert Model.table not in root2 assert MyDefaultModel.table not in root2 assert MyDB2Model.table not in rootd
def check_conflict_resolution(): """ Checks wether sheraf object conflicts resolutions are possible. When this is KO, it is generally because sheraf is not installed in the ZEO environnement, so ZEO cannot solve sheraf object conflicts. """ table_name = "__conflict_resolution_test_model__" nestable = sheraf.Database.get().nestable sheraf.Database.get().nestable = True class TestModel(sheraf.Model): table = table_name counter = sheraf.CounterAttribute(default=0) with sheraf.connection(commit=True): m = TestModel.create() try: with sheraf.connection(commit=True): TestModel.read(m.identifier).counter.increment(1) with sheraf.connection(commit=True): TestModel.read(m.identifier).counter.increment(15) except ZODB.POSException.ConflictError: # pragma: no cover return False else: return True finally: with sheraf.connection(commit=True) as conn: del conn.root()[table_name] sheraf.Database.get().nestable = nestable
def test_model_with_database_name_specified(sheraf_database, db2): class Db2Model(tests.UUIDAutoModel): database_name = "db2" with sheraf.connection(commit=True): m = Db2Model.create() n = Db2Model.create() with sheraf.connection() as connection: assert m.id not in connection.root().get(Db2Model.table, {}) connection_2 = connection.get_connection("db2") assert connection_2.root()[Db2Model.table]["id"][m.id] is m.mapping assert Db2Model.read(m.id) == m assert Db2Model.count() == 2 assert m in Db2Model.all() assert n in Db2Model.all() m.delete() assert m.id not in connection_2.root()[Db2Model.table]["id"] assert Db2Model.count() == 1 n.delete() assert Db2Model not in connection_2.root() assert Db2Model.count() == 0
def test_edit_a_not_single_instance_when_two_indexes_with_key_afterwards( sheraf_database, ): class Model(tests.UUIDAutoModel): my_simple_attribute = sheraf.SimpleAttribute() with sheraf.connection(commit=True): m = Model.create(my_simple_attribute="foo_not_indexed") Model.create(my_simple_attribute="foo_not_indexed2") class Model(tests.UUIDAutoModel): my_simple_attribute = ( sheraf.SimpleAttribute() .index(key="key1") .index(key="key2", values=lambda x: x) ) with sheraf.connection(commit=True): m = Model.read(m.id) with warnings.catch_warnings(record=True) as warning_messages: m.my_simple_attribute = "bar_still_not_indexed" assert any( "key1 will not be indexed." in str(w.message) for w in warning_messages ) with sheraf.connection() as conn: assert "key1" not in conn.root()["model"] assert "key2" not in conn.root()["model"]
def test_nested(sheraf_database, persistent_type, subattribute): class Model(tests.UUIDAutoModel): list = sheraf.ListAttribute( attribute=sheraf.ListAttribute(attribute=subattribute, persistent_type=persistent_type), persistent_type=persistent_type, ) with sheraf.connection(commit=True): m = Model.create(list=[[0, 1], [2, 3]]) assert 0 == m.list[0][0] assert 1 == m.list[0][1] assert 2 == m.list[1][0] assert 3 == m.list[1][1] assert isinstance(m.mapping["list"], persistent_type) assert isinstance(m.mapping["list"][0], persistent_type) assert [0, 1] == list(m.list[0]) with sheraf.connection(commit=True): m = Model.read(m.id) assert 0 == m.list[0][0] assert 1 == m.list[0][1] assert 2 == m.list[1][0] assert 3 == m.list[1][1] assert isinstance(m.mapping["list"], persistent_type) assert isinstance(m.mapping["list"][0], persistent_type) assert [0, 1] == list(m.list[0])
def test_multiprocessing_float_conflict_resolution(sheraf_zeo_database): class FloatModel(tests.UUIDAutoModel): counter = sheraf.CounterAttribute(default=0.5) def process(uri, model_id, barrier, addition): sheraf.Database(uri) with sheraf.connection(commit=True): m = FloatModel.read(model_id) barrier.wait() m.counter.increment(addition) with sheraf.connection(commit=True): m = FloatModel.create() nb_process = 3 barrier = multiprocessing.Barrier(nb_process) processes = [ multiprocessing.Process(target=process, args=(sheraf_zeo_database.uri, m.id, barrier, i + 0.5)) for i in range(0, nb_process) ] for process in processes: process.start() for process in processes: process.join(timeout=10) assert 0 == process.exitcode with sheraf.connection(): m = FloatModel.read(m.id) assert 0.5 + sum(i + 0.5 for i in range(0, nb_process)) == m.counter
def test_integer_tuple(sheraf_database): with sheraf.connection(commit=True) as c: c.root.dict = sheraf.types.LargeDict() for x in range(10): for y in range(10): c.root.dict[(x, y)] = str(x) + "-" + str(y) with sheraf.connection() as c: assert c.root.dict[(5, 0)] == "5-0" with pytest.raises(KeyError): c.root.dict[(100, 100)] assert (2, 5) in c.root.dict assert 100 == len(c.root.dict) with sheraf.connection() as c: assert list(c.root.dict[(9, 8):]) == ["9-8", "9-9"] assert list(c.root.dict[(1, 2):(1, 4)]) == ["1-2", "1-3", "1-4"] assert list(c.root.dict[:(0, 4)]) == ["0-0", "0-1", "0-2", "0-3", "0-4"] assert list(c.root.dict[:]) == [ str(x) + "-" + str(y) for x in range(10) for y in range(10) ] with sheraf.connection() as c: assert list(c.root.dict[(9, 8)::-1]) == ["9-9", "9-8"] assert list(c.root.dict[:(0, 3):-1]) == ["0-3", "0-2", "0-1", "0-0"] assert list(c.root.dict[(1, 0):(1, 2):-1]) == ["1-2", "1-1", "1-0"] assert list(c.root.dict[(9, 0):(9, 4):2]) == ["9-0", "9-2", "9-4"]