def process(uri, model_id, barrier):
sheraf.Database(uri)
with sheraf.connection(commit=True):
m = Model.read(model_id)
barrier.wait()
m.order = "YOLO"
def test_close_database():
db = sheraf.Database()
assert db == sheraf.Database.get()
close_database(db)
with pytest.raises(KeyError):
assert sheraf.Database.get() is None
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)
def magic_connection(*args, **kwargs):
try:
sheraf.Database()
except KeyError:
pass
with previous_connection(*args, **kwargs) as connection:
yield connection
def run(self):
with pytest.raises(KeyError):
sheraf.Database.get()
db = sheraf.Database(self.uri)
with sheraf.connection(commit=True) as conn:
conn.root.list.append("process")
db.close()
def other_database():
database = None
try:
database = sheraf.Database("memory://?database_name=other_database")
yield database
finally:
if database:
database.close()
def profiled_filter_with_demostorage(numdata, clazz, filter_value):
sheraf.Database(storage=DemoStorage(name="demo"))
init_data(clazz, numdata)
result = profiled_filter(clazz, filter_value)
nzeros = str(numdata).count("0")
print("10^{nzeros} objects : {result} secs".format(nzeros=nzeros,
result=result))
return ("10^{nzeros}".format(nzeros=nzeros), result)
def test_nested_connections_on_two_databases_raise_exception(
cacheMinimize, sheraf_database
):
other = sheraf.Database("memory://?database_name=other_database")
with sheraf.connection():
with pytest.raises(sheraf.exceptions.ConnectionAlreadyOpened):
with sheraf.connection(database_name="other_database"):
pass # pragma: no cover
other.close()
def db2(request):
database = None
try:
database = sheraf.Database("memory://?database_name=db2")
yield database
finally:
if database:
database.close()
def other_nested_database():
database = None
try:
database = sheraf.Database(
"memory://?database_name=other_nested_database", nestable=True
)
yield database
finally:
if database:
database.close()
def test_storage():
demo_storage = sheraf.databases.DemoStorage(name="demo")
pool = sheraf.Database(storage=demo_storage)
with sheraf.connection() as C:
db = C.db()
assert db.storage is demo_storage
pool.close()
def concurrent_creation(cls):
class Model(sheraf.Model):
table = "Model"
status = sheraf.SimpleAttribute()
first_id = None
# Create the table if needed:
database = sheraf.Database(cls.DATABASE_URI)
try:
with sheraf.connection(commit=True) as conn:
if conn.root().get(Model.table) is None:
first_id = Model.create(status=1)
def process(uri, barrier):
sheraf.Database(uri)
with sheraf.connection(commit=True):
Model.read(first_id.id)
barrier.wait()
Model.create(status=1)
processes = []
barrier = multiprocessing.Barrier(cls.NUM_PROCESS)
for i in range(0, cls.NUM_PROCESS):
processes.append(
multiprocessing.Process(
target=process, args=(cls.DATABASE_URI, barrier)
)
)
for i in range(0, cls.NUM_PROCESS):
processes[i].start()
for i in reversed(range(0, cls.NUM_PROCESS)):
processes[i].join(timeout=10)
for i in range(0, cls.NUM_PROCESS):
assert 0 == processes[i].exitcode
finally:
if cls.PROVOKE_CONFLICTS:
pass
else:
with sheraf.databases.connection(commit=True) as conn:
for key in list(conn.root().keys()):
del conn.root()[key]
database.close()
def process(uri, model_id, barrier, queue, lock):
sheraf.Database(uri)
with sheraf.connection(commit=True):
m = Model.read(model_id)
barrier.wait()
with lock:
order = queue.get()
if order == "first":
m.something = "YEAH"
elif order == "second":
m.something_else = "YOH"
def process(uri, model_id, barrier, queue, lock, addition):
sheraf.Database(uri)
with sheraf.connection() as conn:
m = Model.read(model_id)
barrier.wait()
m.counter += addition
with lock:
value = queue.get()
if value == "first":
conn.transaction_manager.commit()
if value == "second":
with pytest.raises(ZODB.POSException.ConflictError):
conn.transaction_manager.commit()
def process(uri, model_id, barrier, queue, lock):
sheraf.Database(uri)
with sheraf.connection() as conn:
m = Model.read(model_id)
barrier.wait()
with lock:
order = queue.get()
m.order = order
if order == "first":
conn.transaction_manager.commit()
elif order == "second":
with pytest.raises(ZODB.POSException.ConflictError):
conn.transaction_manager.commit()
def test_disk_usage(self):
max_size = 0
for Model in (
# sheraf.UUIDIndexedDatedNamedAttributesModel,
sheraf.UUIDIndexedNamedAttributesModel,
sheraf.IntIndexedNamedAttributesModel,
sheraf.IntIndexedIntAttributesModel,
):
Account = self.get_Account(Model)
self.clean(Model)
sheraf.Database(
filename="tmp/{}.fs".format(Account.__class__.__name__))
ids = self.build(Account)
self.check(Account, ids)
model_size = sum(
os.stat(f).st_size for f in self.get_db_files(Model))
max_size = max(max_size, model_size)
print((Model.__name__, model_size,
"{:.2f}".format(model_size / max_size)))
def cli(uri):
sys.path.append(".")
db = sheraf.Database(uri)
def process(uri, barrier):
sheraf.Database(uri)
with sheraf.connection(commit=True):
Model.read(first_id.id)
barrier.wait()
Model.create(status=1)
def test_storage_argument(DemoStorage, DB):
pool = sheraf.Database(storage=DemoStorage(name="demo"))
pool.close()
DemoStorage.assert_called_once_with(name="demo")
def test_database_context_manager(cacheMinimize):
db = sheraf.Database()
with db.connection() as connection:
assert sheraf.Database.current_connection() is connection
db.close()
def set_up_database(state):
state._path = tempfile.mkdtemp()
sheraf.Database()
state._old_files_root_dir = sheraf.attributes.files.FILES_ROOT_DIR
sheraf.attributes.files.FILES_ROOT_DIR = os.path.join(
state._path, "files/")
"""charge la base de donnees locale
>>> import sheraf
>>> with sheraf.connection(): # doctest: +SKIP
... pass
"""
import sheraf
if __name__ == "__main__": # pragma: no cover
sheraf.Database(zeo=("localhost", 9999))