async def test_interledger_run_with_cleanup():
l1, l2, l3 = [], [], []
for i in range(4):
l1.append(Transfer())
l2.append(Transfer())
l3.append(Transfer())
init = MockInitiator(l1)
i = Interledger(init, MockResponder())
task = asyncio.ensure_future(i.run())
time = 0.5
# Consume l1
await asyncio.sleep(time) # Simulate interledger running
# New events
init.events = l2
# Consume l2
await asyncio.sleep(time) # Simulate interledger running
# New events
i.responder = MockResponderAbort()
init.events = l3
# Consume l3, but with a responder returning False -> abort
await asyncio.sleep(time) # Simulate interledger running
i.stop()
await task
assert len(i.transfers) == 0
assert len(i.transfers_sent) == 0
def setUp():
# Setup the state
# Deploy contract
# Mint token
# Call accept() from the minter
# Setup web3 and state
url = "HTTP://127.0.0.1"
port = 8545
w3 = Web3(Web3.HTTPProvider(url+":"+str(port)))
abi, bytecode = readContractData(contract_path)
contract_minter = w3.eth.accounts[0]
bob = w3.eth.accounts[1]
token_instance = create_contract(w3, abi, bytecode, contract_minter)
# Create a token
tokenId = 123
tokenURI = "weapons/"
assetId = w3.toBytes(text="Vorpal Sword")
tx_hash = token_instance.functions.mint(bob, tokenId, tokenURI, assetId).transact({'from': contract_minter})
w3.eth.waitForTransactionReceipt(tx_hash)
t = Transfer()
t.data = dict()
t.data["assetId"] = tokenId
return (contract_minter, token_instance, url, port, t)
def return_transfer_list():
t1 = Transfer()
t2 = Transfer()
t3 = Transfer()
t4 = Transfer()
t2.state = State.SENT
t3.state = State.RESPONDED
t4.state = State.FINALIZED
return [t1, t2, t3, t4]
async def test_interledger_run_with_restore_ready():
base = "sofie_asset_transfer"
package = base + ".interledger.StateInterledger"
# Create a new transfer
# for protocol PoW, it should have state (TransferOut | Here)
t = Transfer()
t.data = {}
t.data["assetId"] = 123
with patch(package + ".restore_pending_transfers_ready",
return_value=[t]) as mock_ready:
with patch(package + ".restore_pending_transfers_sent",
return_value=[]) as mock_sent:
interledger = StateInterledger(StateInitiator(), StateResponder())
init = base + ".state_interfaces.StateInitiator"
resp = base + ".state_interfaces.StateResponder"
get_future = asyncio.Future()
receive_future = asyncio.Future()
commit_future = asyncio.Future()
get_future.set_result([])
receive_future.set_result({"status": True})
commit_future.set_result(True)
with patch(init + ".get_transfers",
return_value=get_future) as mock_get_transfers:
with patch(
resp + ".receive_transfer",
return_value=receive_future) as mock_receive_transfer:
with patch(init + ".commit_transfer",
return_value=commit_future) as mock_commit:
with patch(base + ".interledger.Interledger.cleanup"
) as mock_cleanup:
# mock cleanup to check the transfer reaches the end
time = 1
task = asyncio.ensure_future(interledger.run())
await asyncio.sleep(time)
interledger.stop()
await task
assert len(interledger.transfers) == 1
assert len(interledger.transfers_sent) == 1
assert len(interledger.results_commit) == 1
assert interledger.pending == 0
async def test_interledger_process_result_abort():
i = Interledger(MockInitiator([]), None)
t = Transfer()
t.state = State.RESPONDED
t.result = {"status": False}
i.transfers_sent = [t]
i.pending = 1
task = asyncio.ensure_future(i.process_result())
assert task.done() == False
await task
tr = i.transfers_sent[0]
assert tr.state == State.FINALIZED
assert len(i.results_commit) == 0
assert len(i.results_abort) == 1
assert i.pending == 0
async def test_interledger_transfer_result():
async def foo():
return 42
i = Interledger(MockInitiator([]), MockResponder())
t = Transfer()
t.state = State.SENT
t.future = asyncio.ensure_future(foo())
i.transfers_sent = [t]
task = asyncio.ensure_future(i.transfer_result())
assert task.done() == False
await task
tr = i.transfers_sent[0]
assert tr.state == State.RESPONDED
assert tr.result == 42
async def test_interledger_run_no_cleanup():
l1, l2, l3 = [], [], []
for i in range(4):
l1.append(Transfer())
l2.append(Transfer())
l3.append(Transfer())
init = MockInitiator(l1)
i = Interledger(init, MockResponder())
with patch("sofie_asset_transfer.interledger.Interledger.cleanup") as mock_cleanup:
task = asyncio.ensure_future(i.run())
time = 0.5
# Consume l1
await asyncio.sleep(time) # Simulate interledger running
# New events
init.events = l2
# Consume l2
await asyncio.sleep(time) # Simulate interledger running
# New events
i.responder = MockResponderAbort()
init.events = l3
# Consume l3, but with a responder returning False -> abort
await asyncio.sleep(time) # Simulate interledger running
i.stop()
await task
assert len(i.transfers) == 12
assert len(i.transfers_sent) == 12
assert len(i.results_commit) == 8
assert len(i.results_abort) == 4
assert i.pending == 0
async def test_interledger_receive_transfer():
t = Transfer()
init = MockInitiator([t])
resp = MockResponder()
interledger = Interledger(init, resp)
# interledger.test_interrupt = True
task = asyncio.ensure_future(interledger.receive_transfer())
assert task.done() == False
l = await task
assert init.events == []
assert len(interledger.transfers) == 1
assert l == 1
assert interledger.transfers[0].state == State.READY
async def test_interledger_send_transfer():
t = Transfer()
i = Interledger(MockInitiator([]), MockResponder())
i.transfers = [t]
task = asyncio.ensure_future(i.send_transfer())
assert task.done() == False
await task
assert i.pending == 1
tr = i.transfers[0]
assert tr.state == State.SENT
assert asyncio.isfuture(tr.future)
await tr.future
assert tr.future.done() == True