def test_member_add_record_from_dict():
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
asm = AuxSessionManager(app=app)
seq_num = 1
engine = asm.get_engine(seq_num)
session = asm.get(seq_num)
session.query(MemberModel).delete()
assert session.query(MemberModel).count() == 0
d = {
'ecosystem_id': 1,
'key_id': -123,
'address': '456',
'pub': 'a9823432',
'amount': 13.1,
'maxpay': 10.2,
'multi': 1,
'deleted': 1,
'blocked': 1,
}
MemberModel.add_record_from_dict(d, session=session)
assert session.query(MemberModel).count() == 1
i = session.query(MemberModel).first()
for k, v in d.items():
assert hasattr(i, k)
val = getattr(i, k)
if k in ('amount', 'maxpay'):
assert float(v) == float(val)
else:
assert val == v
def test_add_all_records_for_all_ecosystems():
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
asm = AuxSessionManager(app=app)
seq_num = 1
engine = asm.get_engine(seq_num)
session = asm.get(seq_num)
m_session = sm.get(seq_num)
session.query(MemberModel).delete()
assert session.query(MemberModel).count() == 0
assert m_session.query(EsKeys).count() > 0
MemberModel.add_all_records_for_all_ecosystems(EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
total = 0
for es in m_session.query(Ecosystem).all():
EsKeys.set_ecosystem(es.id)
for m_item in m_session.query(EsKeys).all():
item = session.query(MemberModel).filter_by(key_id=m_item.id).one()
assert_eskeys_and_member_instances_eq(m_item, item)
total += m_session.query(EsKeys).count()
assert session.query(MemberModel).count() == total
def create_test_app():
app = create_lean_app()
app.app_context().push()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
return app
def create_test_app():
from genesis_block_explorer.app import create_lean_app as create_app
app = create_app()
app.app_context().push()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
return app
def test_member_object_creation():
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
asm = AuxSessionManager(app=app)
seq_num = 1
engine = asm.get_engine(seq_num)
session = asm.get(seq_num)
create_tables(involved_models, engine)
assert session.query(MemberModel).with_session(
asm.get(seq_num)).count() == 0
def NOtest_do_if_locked():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
sn = 1
session = sm.get(sn)
def test_delete_expired_locks():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
assert LockModel.is_locked(session=session) == False
to = 1
eqs = LockModel.get_expired_locks(session=session, timeout_secs=to)
assert len(eqs) == 0
LockModel.lock(session=session)
assert LockModel.is_locked(session=session) == True
assert session.query(LockModel).count() == 1
lock = LockModel.get_latest_lock(session=session)
eqs = LockModel.get_expired_locks(session=session, timeout_secs=to)
assert len(eqs) == 0
print("Pausing for %d seconds ..." % (to + 1))
time.sleep(to + 1)
LockModel.lock(session=session)
assert session.query(LockModel).count() == 2
eqs = LockModel.get_expired_locks(session=session, timeout_secs=to)
assert len(eqs) == 1
LockModel.delete_expired_locks(session=session, timeout_secs=to)
eqs = LockModel.get_expired_locks(session=session, timeout_secs=to)
assert len(eqs) == 0
assert session.query(LockModel).count() == 1
def test_update_aux_db_engine_discovery_map():
app = create_test_app()
app.config['AUX_DB_ENGINE_DISCOVERY_MAP'] = {'test_bind_name1': 'some'}
src_config = app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP').copy()
new_aux_map = update_aux_db_engine_discovery_map(app)
assert src_config == app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')
new_aux_map = update_aux_db_engine_discovery_map(app, force_update=True)
assert src_config != app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')
for name, value in app.config.get('DB_ENGINE_DISCOVERY_MAP').items():
assert 'aux_' + name in app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')
assert app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')['aux_' + name] == value
new_aux_map = update_aux_db_engine_discovery_map(app, force_update=True,
aux_db_engine_name_prefix='test_aux_')
assert src_config != app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')
for name, value in app.config.get('DB_ENGINE_DISCOVERY_MAP').items():
assert 'test_aux_' + name in app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')
assert app.config.get('AUX_DB_ENGINE_DISCOVERY_MAP')['test_aux_' + name] == value
def test_multi_context_locking():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(app, force_update=True,
aux_db_engine_name_prefix='test_aux_')
f = Filler(app=app)
f.unlock()
tf = TestFiller(app=app)
tf.unlock()
assert not f.is_locked
assert not tf.is_locked
def test_member_add_record_from_model_instance():
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
asm = AuxSessionManager(app=app)
seq_num = 1
engine = asm.get_engine(seq_num)
session = asm.get(seq_num)
m_session = sm.get(seq_num)
session.query(MemberModel).delete()
assert session.query(MemberModel).count() == 0
assert m_session.query(EsKeys).count() > 0
ecosystem_id = 1
EsKeys.set_ecosystem(ecosystem_id)
m_instance = m_session.query(EsKeys).first()
assert isinstance(m_instance, EsKeys)
MemberModel.add_record_from_model_instance(m_instance, session=session)
assert session.query(MemberModel).count() == 1
instance = session.query(MemberModel).first()
assert_eskeys_and_member_instances_eq(m_instance, instance)
def test_compare_num_of_all_records_for_all_ecosystems():
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
asm = AuxSessionManager(app=app)
seq_num = 1
engine = asm.get_engine(seq_num)
session = asm.get(seq_num)
m_session = sm.get(seq_num)
session.query(MemberModel).delete()
assert session.query(MemberModel).count() == 0
assert m_session.query(EsKeys).count() > 0
MemberModel.add_all_records_for_all_ecosystems(EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
l = session.query(MemberModel).count()
assert l > 0
MemberModel.compare_num_of_all_records_for_all_ecosystems(
EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
session.delete(session.query(MemberModel).first())
session.commit()
l2 = session.query(MemberModel).count()
assert l > l2
compare_num_error_caught = False
try:
MemberModel.compare_num_of_all_records_for_all_ecosystems(
EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
except MemberModel.CompareNumError:
compare_num_error_caught = True
assert compare_num_error_caught
def test_add():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LogModel], sm.get_engine(seq_num))
assert len(LogModel.query.with_session(session=session).all()) == 0
LogModel.add(session=session, context='filler', caller='fill_block')
assert len(LogModel.query.with_session(session=session).all()) == 1
LogModel.add(session=session, context='filler', caller='fill_block')
assert len(LogModel.query.with_session(session=session).all()) == 2
def NOtest_get_bind_name():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
sn = 1
if len(app.config['AUX_DB_ENGINE_DISCOVERY_MAP']) == 0:
try:
sm.get_bind_name(sn)
except DbEngineMapIsEmptyError as e:
print("AUX_DB_ENGINE_DISCOVERY_MAP is empty")
return
assert sm.get_bind_name(sn) == tuple(
app.config['AUX_DB_ENGINE_DISCOVERY_MAP'].keys())[0]
def test_get_latest_lock():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
assert LockModel.is_locked(session=session) == False
LockModel.lock(session=session)
assert LockModel.is_locked(session=session) == True
q = LockModel.get_latest_lock(session=session)
assert isinstance(q, LockModel)
LockModel.unlock(session=session)
q = LockModel.get_latest_lock(session=session)
assert q is None
def test_do_if_locked():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(app, force_update=True,
aux_db_engine_name_prefix='test_aux_')
f = Filler(app=app)
f.do_if_locked()
f.lock()
FillerIsLockedError
filler_is_locked_error_caught = False
try:
f.do_if_locked()
except FillerIsLockedError as e:
#print("Exception caught: %s" % e)
filler_is_locked_error_caught = True
assert filler_is_locked_error_caught
f.unlock()
f.do_if_locked()
def test_clear_garbage():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
assert LockModel.is_locked(session=session) == False
to = 1
fake_pid = get_fake_pid()
LockModel.lock(session=session)
time.sleep(to + 1)
LockModel.lock(session=session)
LockModel.lock(session=session, process_id=fake_pid)
assert LockModel.is_locked(session=session) == True
assert session.query(LockModel).count() == 3
qs = session.query(LockModel).all()
qs_pids = [q.process_id for q in qs]
assert fake_pid in qs_pids
q = LockModel.get_latest_lock(session=session)
assert isinstance(q, LockModel)
assert session.query(LockModel).count() == 3
zqs = LockModel.get_zombie_locks(session=session)
zqs_pids = [q.process_id for q in zqs]
assert len(zqs_pids) == 1
assert fake_pid in zqs_pids
eqs = LockModel.get_expired_locks(session=session, timeout_secs=to)
assert len(eqs) == 1
LockModel.clear_garbage(session=session, timeout_secs=to)
zqs = LockModel.get_zombie_locks(session=session)
zqs_pids = [q.process_id for q in zqs]
assert len(zqs_pids) == 0
eqs = LockModel.get_expired_locks(session=session, timeout_secs=to)
assert len(eqs) == 0
LockModel.unlock(session=session)
assert session.query(LockModel).count() == 0
def NOtest_update_from_block():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
sn = 1
#create_tables([BlockModel, HeaderModel, TxModel, ParamModel], sm.get_engine(sn))
if len(app.config['AUX_DB_ENGINE_DISCOVERY_MAP']) == 0:
try:
sm.get(sn)
except DbEngineMapIsEmptyError as e:
print("AUX_DB_ENGINE_DISCOVERY_MAP is empty")
return
len_first = len(BlockModel.query.with_session(sm.get(sn)).all())
block = Block(b64decode_hashes=True, from_detailed_dict=d3[0])
BlockModel.update_from_block(block, session=sm.get(sn))
try:
BlockModel.update_from_block(block, session=sm.get(sn))
except exc.IntegrityError:
pass
def test_lock():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
assert LockModel.is_locked(session=session) == False
LockModel.lock(session=session)
assert LockModel.is_locked(session=session) == True
LockModel.lock(session=session)
assert LockModel.is_locked(session=session) == True
assert LockModel.is_locked(session=session, context='filler') == False
LockModel.lock(session=session, context='filler')
assert LockModel.is_locked(session=session, context='filler') == True
LockModel.lock(session=session, context='filler')
assert LockModel.is_locked(session=session, context='filler') == True
def test_is_locked():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
# default context
assert len(LockModel.query.with_session(session=session).all()) == 0
assert LockModel.is_locked(session=session) == False
l = LockModel()
session.add(l)
session.commit()
assert len(LockModel.query.with_session(session=session).all()) == 1
l = LockModel()
session.add(l)
session.commit()
assert len(LockModel.query.with_session(session=session).all()) == 2
assert LockModel.is_locked(session=session) == True
# filler context
assert len(
LockModel.query.with_session(session=session).filter_by(
context='filler').all()) == 0
assert LockModel.is_locked(session=session, context='filler') == False
l = LockModel(context='filler')
session.add(l)
session.commit()
assert len(
LockModel.query.with_session(session=session).filter_by(
context='filler').all()) == 1
assert LockModel.is_locked(session=session, context='filler') == True
l = LockModel(context='filler')
session.add(l)
session.commit()
assert len(
LockModel.query.with_session(session=session).filter_by(
context='filler').all()) == 2
assert LockModel.is_locked(session=session, context='filler') == True
def test_delete_zombie_locks():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
assert LockModel.is_locked(session=session) == False
fake_pid = get_fake_pid()
LockModel.lock(session=session)
LockModel.lock(session=session, process_id=fake_pid)
assert LockModel.is_locked(session=session) == True
assert session.query(LockModel).count() == 2
qs = session.query(LockModel).all()
qs_pids = [q.process_id for q in qs]
assert fake_pid in qs_pids
q = LockModel.get_latest_lock(session=session)
assert isinstance(q, LockModel)
assert session.query(LockModel).count() == 2
zqs = LockModel.get_zombie_locks(session=session)
zqs_pids = [q.process_id for q in zqs]
assert len(zqs_pids) == 1
assert fake_pid in zqs_pids
LockModel.delete_zombie_locks(session=session)
zqs = LockModel.get_zombie_locks(session=session)
zqs_pids = [q.process_id for q in zqs]
assert len(zqs_pids) == 0
LockModel.unlock(session=session)
assert session.query(LockModel).count() == 0
from genesis_block_explorer.models.genesis.aux.utils import (key_id_to_address)
from .blockchain_commons import d1, d3, get_txs
from .test_models_genesis_aux_block import (
my_setup,
my_teardown,
create_tables,
create_test_app,
update_aux_db_engine_discovery_map,
)
seq_nums = (1, ) # 2, 3)
involved_models = [MemberModel]
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
from genesis_block_explorer.models.db_engine.session import SessionManager
from genesis_block_explorer.models.genesis.explicit import (
get_ecosystem_model,
get_keys_model,
)
ALLOW_BACKEND_DISTRUCTIVE_TESTS = False
sm = SessionManager(app=app)
EsKeys = get_keys_model(backend_features=sm.get_be_features(1))
Ecosystem = get_ecosystem_model(backend_features=sm.get_be_features(1))
@with_setup(my_setup, my_teardown)
def nontest_update_all_records_for_all_ecosystems():
app = create_test_app()
update_aux_db_engine_discovery_map(app,
force_update=True,
aux_db_engine_name_prefix='test_aux_')
asm = AuxSessionManager(app=app)
seq_num = 1
engine = asm.get_engine(seq_num)
session = asm.get(seq_num)
m_session = sm.get(seq_num)
session.query(MemberModel).delete()
assert session.query(MemberModel).count() == 0
assert m_session.query(EsKeys).count() > 0
MemberModel.add_all_records_for_all_ecosystems(EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
total = 0
for es in m_session.query(Ecosystem).all():
EsKeys.set_ecosystem(es.id)
total += m_session.query(EsKeys).count()
assert session.query(MemberModel).count() == total
MemberModel.compare_num_of_all_records_for_all_ecosystems(
EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
l = session.query(MemberModel).count()
assert l > 0
session.delete(session.query(MemberModel).first())
l2 = session.query(MemberModel).count()
assert l2 == l - 1
MemberModel.update_all_records_for_all_ecosystems(
EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
l3 = session.query(MemberModel).count()
assert l3 == l
m_l = m_session.query(EsKeys).count()
assert l3 == m_l
if ALLOW_BACKEND_DISTRUCTIVE_TESTS:
m_item = m_session.query(EsKeys).first()
m_data = m_item.to_dict()
m_item_new = EsKeys(**m_data)
m_session.delete(m_item)
m_session.commit()
m_l2 = m_session.query(EsKeys).count()
MemberModel.update_all_records_for_all_ecosystems(
EsKeys,
ecosystem_model=Ecosystem,
session=session,
model_session=m_session)
l4 = session.query(MemberModel).count()
assert l4 == m_l2
m_session.add(m_item_new)
m_session.commit()
m_l3 = m_session.query(EsKeys).count()
assert m_l == m_l3
def test_get_zombie_locks():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(
app, force_update=True, aux_db_engine_name_prefix='test_aux_')
sm = AuxSessionManager(app=app)
seq_num = 1
session = sm.get(seq_num)
create_tables([LockModel], sm.get_engine(seq_num))
assert LockModel.is_locked(session=session) == False
LockModel.lock(session=session)
assert LockModel.is_locked(session=session) == True
q = LockModel.get_latest_lock(session=session)
assert isinstance(q, LockModel)
assert session.query(LockModel).count() == 1
LockModel.unlock(session=session)
assert session.query(LockModel).count() == 0
LockModel.lock(session=session)
assert LockModel.is_locked(session=session) == True
q = LockModel.get_latest_lock(session=session)
assert isinstance(q, LockModel)
assert session.query(LockModel).count() == 1
LockModel.lock(session=session)
assert session.query(LockModel).count() == 2
LockModel.unlock(session=session)
assert session.query(LockModel).count() == 0
#n = os.fork()
#LockModel.lock(session=session)
#assert LockModel.is_locked(session=session) == True
#q = LockModel.get_latest_lock(session=session)
#print("q: %s" % q)
#print("is instance: %s" % isinstance(q, LockModel))
#assert isinstance(q, LockModel)
#if n > 0:
# print("Parent process and id is : ", os.getpid())
#else:
# print("Child process and id is : ", os.getpid())
# return
# os._exit(0)
#time.sleep(1)
#assert session.query(LockModel).count() == 2
#LockModel.unlock(session=session)
#assert session.query(LockModel).count() == 0
fake_pid = get_fake_pid()
LockModel.lock(session=session)
LockModel.lock(session=session, process_id=fake_pid)
assert LockModel.is_locked(session=session) == True
assert session.query(LockModel).count() == 2
qs = session.query(LockModel).all()
qs_pids = [q.process_id for q in qs]
assert fake_pid in qs_pids
q = LockModel.get_latest_lock(session=session)
assert isinstance(q, LockModel)
assert session.query(LockModel).count() == 2
zqs = LockModel.get_zombie_locks(session=session)
zqs_pids = [q.process_id for q in zqs]
assert len(zqs_pids) == 1
assert fake_pid in zqs_pids
LockModel.unlock(session=session)
assert session.query(LockModel).count() == 0
def test_check_dbs():
app = create_test_app()
new_map = update_aux_db_engine_discovery_map(app, force_update=True,
aux_db_engine_name_prefix='test_aux_')
f = Filler(app=app)
f.check_dbs()
