def test_sync_on_getattr():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = Car(id=44, gas_level=0, color="green")
mgr.cars.add(car)
car._sync_on_getattr = True
assert car.color == "green"
db.update("cars", id=car.id, color="blue")
assert car.color == "blue"
def test_underlying_delete():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = Car(id=44, gas_level=0, color="green")
mgr.cars.add(car)
assert db.select_one("cars", id=car.id)
db.delete("cars", id=car.id)
car2 = Car(id=44, gas_level=0, color="green")
mgr.cars.add(car2)
assert car2 is not car
assert mgr.cars.get(id=44) is car2
def test_threaded_reads():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = mgr.cars.add(Car(gas_level=0, color=str(0)))
pool = ThreadPool(50)
# to reproduce the problem with this, you need to catch python while switching contexts
# in between setattr calls in a non-atomic "apply" function
# this is basically impossible without sticking a time sleep in there
# even with 100 attributes and 5000 threads it never failed
# so this test case only tests if the atomic apply is totally/deeply broken
def update_stuff(_i):
time.sleep(0.00001)
assert car.color == str(car.gas_level)
with car:
car.gas_level += 1
time.sleep(0.00001)
car.color = str(car.gas_level)
assert car.color == str(car.gas_level)
time.sleep(0.00001)
assert car.color == str(car.gas_level)
# lots of threads can update stuff
num_t = 10
pool.map(update_stuff, range(num_t))
assert car.gas_level == num_t
def test_thread_locked_writer_only():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = mgr.cars.add(Car(gas_level=0, color=str(0)))
num_t = 15
num_w = 3
pool = ThreadPool(num_t)
# to reproduce the problem with this, you need to catch python while switching contexts
# in between setattr calls in a non-atomic "apply" function
# this is basically impossible without sticking a time sleep in there
# even with 100 attributes and 5000 threads it never failed
# so this test case only tests if the atomic apply is totally/deeply broken
def update_stuff(i):
if i < num_w:
with car:
car.gas_level += 1
car.color = str(car.gas_level)
time.sleep(0.1)
else:
with pytest.raises(OmenUseWithError):
car.gas_level += 1
# lots of threads can update stuff
pool.map(update_stuff, range(num_t))
assert car.gas_level == num_w
def test_disable_allow_auto():
db = SqliteDb(":memory:")
with patch.object(Cars, "allow_auto", False):
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
with pytest.raises(OmenNoPkError):
mgr.cars.add(Car(gas_level=0, color="green"))
def test_deadlock():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
car = mgr.cars.add(Car(gas_level=2))
def insert(i):
try:
with car:
car.gas_level = i
if i == 0:
time.sleep(1)
return True
except OmenLockingError:
return False
num = 3
pool = ThreadPool(num)
ret = pool.map(insert, range(num))
assert sorted(ret) == [False, False, True]
pool.terminate()
pool.join()
def test_cascade_relations():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
car = mgr.cars.add(Car(id=1, gas_level=2, color="green"))
assert not car._is_new
with car:
car.doors.add(gen_objs.doors_row(type="z"))
car.doors.add(gen_objs.doors_row(type="x"))
assert len(car.doors) == 2
with car:
car.id = 3
assert len(car.doors) == 2
assert mgr.cars.select_one(id=3)
assert not mgr.cars.select_one(id=1)
# cascaded remove
assert len(list(mgr.db.select("doors"))) == 2
car._remove()
assert len(list(mgr.db.select("doors"))) == 0
def test_type_checking():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
Car._type_check = True
mgr.cars = Cars(mgr)
car = mgr.cars.add(Car(gas_level=0, color="green"))
with pytest.raises(TypeError):
with car:
car.color = None
with pytest.raises(TypeError):
with car:
car.color = 4
with pytest.raises(TypeError):
with car:
car.gas_level = "hello"
with pytest.raises(TypeError):
with car:
car.color = b"ggh"
car._type_check = False
# notanorm integrity error because color is a required field
with pytest.raises(notanorm.errors.IntegrityError):
with car:
car.color = None
# sqlite allows this, so we do too, since type checking is off
with car:
car.color = b"ggh"
def test_readme(tmp_path):
fname = str(tmp_path / "test.txt")
db = SqliteDb(fname)
mgr = MyOmen(db)
# cars pk is autoincrement
assert Cars.allow_auto
mgr.cars = Cars(mgr)
# by default, you can always iterate on tables
assert mgr.cars.count() == 0
car = Car() # creates a default car (black, full tank)
car.color = "red"
car.gas_level = 0.5
car.doors.add(gen_objs.doors_row(type="a"))
car.doors.add(gen_objs.doors_row(type="b"))
car.doors.add(gen_objs.doors_row(type="c"))
car.doors.add(gen_objs.doors_row(type="d"))
assert not car.id
mgr.cars.add(car)
# cars have ids, generated by the db
assert car.id
with pytest.raises(AttributeError, match=r".*gas.*"):
mgr.cars.add(Car(color="red", gas=0.3))
mgr.cars.add(
Car(
color="red",
gas_level=0.3,
doors=[gen_objs.doors_row(type=str(i)) for i in range(4)],
))
assert sum(1 for _ in mgr.cars.select(color="red")) == 2 # 2
log.info("cars: %s", list(mgr.cars.select(color="red")))
car = mgr.cars.select_one(color="red", gas_level=0.3)
assert not car._is_new
with car:
with pytest.raises(AttributeError, match=r".*gas.*"):
car.gas = 0.9
car.gas_level = 0.9
types = set()
for door in car.doors:
types.add(int(door.type))
assert types == set(range(4))
# doors are inserted
assert len(car.doors) == 4
def test_remove_driver():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
mgr.car_drivers = CarDrivers(mgr)
Driver = gen_objs.drivers
mgr.drivers = mgr[Driver]
car1 = mgr.cars.add(Car(id=1, gas_level=2, color="green"))
car2 = mgr.cars.add(Car(id=2, gas_level=2, color="green"))
driver1 = mgr.drivers.new(name="bob")
driver2 = mgr.drivers.new(name="joe")
car1.car_drivers.add(CarDriver(carid=car1.id, driverid=driver1.id))
car2.car_drivers.add(CarDriver(carid=car2.id, driverid=driver1.id))
assert len(car1.car_drivers) == 1
assert len(car2.car_drivers) == 1
for cd in car1.car_drivers:
car1.car_drivers.remove(cd)
assert len(car1.car_drivers) == 0
assert len(car2.car_drivers) == 1
assert len(list(mgr.db.select("drivers"))) == 2
assert len(list(mgr.db.select("car_drivers"))) == 1
car1.car_drivers.add(CarDriver(carid=car1.id, driverid=driver1.id))
assert len(car1.car_drivers) == 1
mgr.car_drivers.remove(carid=car1.id, driverid=driver1.id)
# ok to double-remove
mgr.car_drivers.remove(carid=car1.id, driverid=driver1.id)
# removing None is a no-op (ie: remove.(select_one(criteria....)))
mgr.car_drivers.remove(None)
assert len(car1.car_drivers) == 0
assert len(car2.car_drivers) == 1
car2.car_drivers.add(CarDriver(carid=car2.id, driverid=driver2.id))
assert len(list(mgr.db.select("car_drivers"))) == 2
with pytest.raises(OmenMoreThanOneError):
# kwargs remove is not a generic method for removing all matching things
# make your own loop if that's what you want
mgr.car_drivers.remove(carid=car2.id)
def test_need_with():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
car = mgr.cars.add(Car(gas_level=2))
with pytest.raises(OmenUseWithError):
car.doors = "green"
assert car._manager is mgr
assert mgr.cars.manager is mgr
def test_cache():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = Cars(mgr)
orig = mgr.cars
cars = ObjCache(mgr.cars)
# replace the table with a cache
mgr.cars = cars
mgr.cars.add(Car(gas_level=2, color="green"))
mgr.cars.add(Car(gas_level=3, color="green"))
assert cars.select_one(id=1)
assert cars.count() == 2
assert orig._cache
mgr.db.insert("cars", id=99, gas_level=99, color="green")
mgr.db.insert("cars", id=98, gas_level=98, color="green")
# this won't hit the db
# noinspection PyUnresolvedReferences
assert not any(car.id == 99 for car in mgr.cars.select())
# this won't hit the db
assert not cars.select_one(id=99)
# this will
assert cars.table.select(id=99)
# now the cache is full
assert cars.select(id=99)
# but still missing others
assert not cars.select_one(id=98)
assert cars.reload() == 4
log.debug(orig._cache)
# until now
assert cars.select_one(id=98)
def test_iter_and_sort():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
mgr.cars.add(Car(gas_level=2, color="green"))
car = mgr.cars.add(Car(gas_level=3, color="green"))
with car:
car.doors.add(gen_objs.doors_row(type="z"))
car.doors.add(gen_objs.doors_row(type="x"))
# tables, caches and relations are all sortable, and iterable
for door in car.doors:
assert door
sorted(car.doors)
sorted(mgr.cars)
cars = ObjCache(mgr.cars)
mgr.cars = cars
sorted(mgr.cars)
def test_nested_with():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
car = mgr.cars.add(Car(id=4, gas_level=2))
with car:
car.gas_level = 3
with pytest.raises(OmenLockingError):
with car:
car.color = "blx"
assert db.select_one("cars", id=4).gas_level == 3
def test_unbound_add():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = Car(id=44, gas_level=0, color="green")
door = gen_objs.doors_row(type="a")
car.doors.add(door)
assert door.carid == car.id
assert door.carid
assert door in car.doors
assert car.doors.select_one(type="a")
mgr.cars.add(car)
assert db.select_one("doors", carid=car.id, type="a")
def test_update_only():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
car = mgr.cars.add(Car(id=4, gas_level=2))
with car:
car.gas_level = 3
# hack in the color....
car.__dict__["color"] = "blue"
assert "gas_level" in car._changes
assert "color" not in car._changes
# color doesn't change in db, because we only update "normally-changed" attributes
assert db.select_one("cars", id=4).gas_level == 3
assert db.select_one("cars", id=4).color == "black"
def test_reload_from_disk():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = mgr.cars.add(Car(gas_level=0, color="green"))
assert db.select_one("cars", id=1).color == "green"
db.update("cars", id=1, color="blue")
# doesn't notice db change because we have a weakref-cache
assert car.color == "green"
car2 = mgr.cars.select_one(id=1)
# weakref cache
assert car2 is car
# db fills to cache on select
assert car.color == "blue"
def test_rollback():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
mgr.cars = mgr[Cars]
car = mgr.cars.add(Car(gas_level=2))
with suppress(ValueError):
with car:
car.gas_level = 3
raise ValueError
assert car.gas_level == 2
with car:
car.gas_level = 3
raise OmenRollbackError
assert car.gas_level == 2
def test_threaded():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = mgr.cars.add(Car(gas_level=0))
pool = ThreadPool(10)
def update_stuff(_i):
with car:
car.gas_level += 1
# lots of threads can update stuff
num_t = 10
pool.map(update_stuff, range(num_t))
assert car.gas_level == num_t
# written to db
assert mgr.db.select_one("cars", id=car.id).gas_level == num_t
def test_weak_cache(caplog):
# important to disable log capturing/reporting otherwise refs to car() could be out there!
caplog.clear()
caplog.set_level("ERROR")
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
car = mgr.cars.add(Car(gas_level=0))
# cache works
car2 = mgr.cars.select_one(gas_level=0)
assert id(car2) == id(car)
assert len(mgr.cars._cache.data) == 1
# weak dict cleans up
del car
del car2
gc.collect()
assert not mgr.cars._cache.data
def test_cache_sharing():
db = SqliteDb(":memory:")
mgr = MyOmen(db)
mgr.cars = Cars(mgr)
cache = ObjCache(mgr.cars)
car = Car(id=44, gas_level=0, color="green")
cache.add(car)
assert car in mgr.cars
assert car in cache
db.insert("cars", id=45, gas_level=45, color="blue")
db.insert("cars", id=46, gas_level=46, color="red")
assert cache.get(id=44)
assert not cache.select_one(id=45)
assert not cache.select_one(id=46)
assert mgr.cars.select_one(id=45)
assert cache.select_one(id=45)
assert mgr.cars.select_one(id=46)
assert cache.select_one(id=46)
db.delete("cars", id=44)
# still cached
assert cache.get(id=44)
assert cache.select_one(id=44)
# still cached, select with a different filter does not clear cache
assert mgr.cars.select_one(id=45)
assert cache.select_one(id=44)
# cache updated by select with matching filter
assert not mgr.cars.select_one(id=44)
assert not cache.select_one(id=44)
# select() with no filter clears cache
db.delete("cars", id=46)
assert len(list(mgr.cars.select())) == 1
assert not cache.select_one(id=46)
# reload() clears cache
assert cache.get(id=45)
db.delete("cars", id=45)
cache.reload()
assert not cache.select_one(id=45)
def test_unbound_basics():
c1 = Car(id=4, color="green", gas_level=5)
c2 = Car(id=5, color="green", gas_level=5)
s = {c1, c2}
assert c1 in s
assert c2 in s
assert c1 != c2
cx = Car(id=4, color="green", gas_level=5)
# equality is defined by primary key equality
assert cx == c1
dct = c1._to_db()
assert str(c1) == str(dct)
cx.id = None
with pytest.raises(OmenNoPkError):
_ = {cx}
# ok to use with on unbound - does nothing
with c1:
pass
def test_nodup():
db = SqliteDb(":memory:")
mgr = MyOmen(db, cars=Cars)
car = mgr[Cars].add(Car(gas_level=2))
with pytest.raises(IntegrityError):
mgr[Cars].add(Car(id=car.id, gas_level=3))
