def test_removal_of_priors(manager, dummy_wallet, db_session, mock_queue_sig):
uuid1 = str_uuid()
uuid2 = str_uuid()
uuid3 = str_uuid()
manager.send_eth(uuid1, 100, deterministic_address_1, dummy_wallet.address)
db_session.commit()
# Create two tasks, both dependent on task 1
manager.send_eth(uuid2, 100, deterministic_address_1, dummy_wallet.address, prior_tasks=[uuid1])
db_session.commit()
manager.send_eth(uuid3, 100, deterministic_address_1, dummy_wallet.address, prior_tasks=[uuid1])
db_session.commit()
task_1 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid1).first()
task_2 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid2).first()
task_3 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid3).first()
assert task_1.posterior_tasks == [task_2, task_3]
assert task_2.prior_tasks == [task_1]
manager.remove_prior_task_dependency(uuid2, uuid1)
# Make sure only the task1<>task2 dependency is removed
assert task_1.posterior_tasks == [task_3]
assert task_2.prior_tasks == []
assert task_3.prior_tasks == [task_1]
sig_output = mock_queue_sig[-1][0]
# Make sure task2 is sent to the queue for retry
assert sig_output.task == 'ETHEREUM.celery_tasks.attempt_transaction'
assert sig_output.kwargs == {'task_uuid': uuid2}
def test_task_relationships(self, db_session):
prior = BlockchainTask(uuid=str_uuid())
posterior = BlockchainTask(uuid=str_uuid())
posterior.prior_tasks.append(prior)
db_session.add_all([prior, posterior])
db_session.commit()
assert prior in posterior.prior_tasks
assert posterior in prior.posterior_tasks
def test_remove_all_posterior_dependencies(manager, dummy_wallet, db_session, mock_queue_sig):
uuid0 = str_uuid()
uuid1 = str_uuid()
uuid2 = str_uuid()
uuid3 = str_uuid()
# Include a task 0 that we won't remove dependencies for
manager.send_eth(uuid0, 100, deterministic_address_1, dummy_wallet.address)
db_session.commit()
manager.send_eth(uuid1, 100, deterministic_address_1, dummy_wallet.address)
db_session.commit()
# Create two tasks, both dependent on task 1 and task 0
manager.send_eth(uuid2, 100, deterministic_address_1, dummy_wallet.address, prior_tasks=[uuid1, uuid0])
db_session.commit()
manager.send_eth(uuid3, 100, deterministic_address_1, dummy_wallet.address, prior_tasks=[uuid1, uuid0])
db_session.commit()
task_0 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid0).first()
task_1 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid1).first()
task_2 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid2).first()
task_3 = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid3).first()
assert task_0.posterior_tasks == [task_2, task_3]
assert task_1.posterior_tasks == [task_2, task_3]
assert task_2.prior_tasks == [task_0, task_1]
assert task_3.prior_tasks == [task_0, task_1]
manager.remove_all_posterior_dependencies(uuid1)
# Make sure all posterior dependencies are removed, but other priors are unaffected
assert task_1.posterior_tasks == []
assert task_2.prior_tasks == [task_0]
assert task_3.prior_tasks == [task_0]
sig_output1 = mock_queue_sig[-2][0]
sig_output2 = mock_queue_sig[-1][0]
# Make sure task2 is sent to the queue for retry
assert sig_output1.task == 'ETHEREUM.celery_tasks.attempt_transaction'
assert sig_output1.kwargs == {'task_uuid': uuid2}
# Make sure task3 is sent to the queue for retry
assert sig_output2.task == 'ETHEREUM.celery_tasks.attempt_transaction'
assert sig_output2.kwargs == {'task_uuid': uuid3}
def test_transaction_status_propagation(self, db_session):
task = BlockchainTask(uuid=str_uuid())
assert task.status == 'UNSTARTED'
transaction_1 = BlockchainTransaction()
transaction_1.task = task
transaction_1.status = 'PENDING'
assert task.status == 'PENDING'
transaction_2 = BlockchainTransaction()
transaction_2.task = task
transaction_2.status = 'SUCCESS'
assert task.status == 'SUCCESS'
assert task.status_code == 1
db_session.add_all([task, transaction_1, transaction_2])
db_session.commit()
# Uses a custom expression so worth testing the filter
queried_task = db_session.query(BlockchainTask).filter(
BlockchainTask.status == 'SUCCESS').first()
assert queried_task == task
def test_add_prior_tasks(self, db_session,
persistence_module: SQLPersistenceInterface):
prior_1 = BlockchainTask(uuid=str_uuid())
prior_2 = BlockchainTask(uuid=str_uuid())
uuid_1 = prior_1.uuid
uuid_2 = prior_2.uuid
posterior = BlockchainTask(uuid=str_uuid())
db_session.add_all([prior_1, prior_2, posterior])
db_session.commit()
posterior.add_prior_tasks([uuid_1, uuid_2])
assert prior_1 in posterior.prior_tasks
assert prior_2 in posterior.prior_tasks
def dummy_task(db_session, dummy_wallet):
from sql_persistence.models import BlockchainTask
task = BlockchainTask(uuid=str_uuid(), signing_wallet=dummy_wallet)
db_session.add(task)
db_session.commit()
return task
def test_set_task_type(self, db_session):
prior = BlockchainTask(uuid=str_uuid())
prior.type = 'SEND_ETH'
assert prior.type == 'SEND_ETH'
with pytest.raises(ValueError):
prior.type = 'NOT_A_TYPE'
def test_duplicate_task_uuids_not_accepted(manager, dummy_wallet, db_session):
uuid = str_uuid()
t1 = manager.send_eth(uuid, 100, deterministic_address_1, dummy_wallet.address)
t2 = manager.send_eth(uuid, 100, deterministic_address_1, dummy_wallet.address)
matching_tasks = db_session.query(BlockchainTask).filter(BlockchainTask.uuid == uuid).all()
assert len(matching_tasks) == 1
assert t1 == t2
assert matching_tasks[0].id == t1
def test_create_blockchain_transaction(
self, db_session, persistence_module: SQLPersistenceInterface):
wallet = BlockchainWallet()
db_session.add(wallet)
task = BlockchainTask(str_uuid())
task.signing_wallet = wallet
db_session.add(task)
trans = persistence_module.create_blockchain_transaction(
task_uuid=task.uuid)
assert trans.task.uuid == task.uuid
def test_deploy_contract_test(self, db_session,
persistence_module: SQLPersistenceInterface):
signing_wallet_obj = BlockchainWallet()
db_session.add(signing_wallet_obj)
uuid = str_uuid()
contract_name = 'ERC20'
args = []
kwargs = None
gas_limit = None
prior_tasks = None
trans = persistence_module.create_deploy_contract_task(
uuid, signing_wallet_obj, contract_name, args, kwargs, gas_limit,
prior_tasks)
assert trans.uuid == uuid
assert trans.type == 'DEPLOY_CONTRACT'
def test_create_function_task(self, db_session,
persistence_module: SQLPersistenceInterface):
signing_wallet_obj = BlockchainWallet()
db_session.add(signing_wallet_obj)
uuid = str_uuid()
contract_address = '0x1234'
abi_type = "ERC20" # aka contract_type
function_name = "transferFrom"
args = ['0x1234', '0x2345', int(1e36)]
kwargs = None
signing_address = None
encrypted_private_key = None
gas_limit = None
prior_tasks = None
reserves_task = None
trans = persistence_module.create_function_task(
uuid, signing_wallet_obj, contract_address, abi_type,
function_name, args, kwargs, gas_limit, prior_tasks, reserves_task)
assert trans.uuid == uuid
assert trans.type == 'FUNCTION'
def mock_response(sig, countdown=0):
return str_uuid()
def mock_response(sig, countdown=0):
queued_sigs.append((sig, countdown))
return str_uuid()
