def test_state_transition():
""" Happy case testing. """
amount = 7
block_number = 1
initiator = factories.HOP6
expire = block_number + factories.UNIT_REVEAL_TIMEOUT
from_route, from_transfer = factories.make_from(
amount,
factories.ADDR,
expire,
initiator,
)
init = ActionInitTarget(
factories.ADDR,
from_route,
from_transfer,
block_number,
)
init_transition = target.state_transition(None, init)
assert init_transition.new_state is not None
assert init_transition.new_state.from_route == from_route
assert init_transition.new_state.from_transfer == from_transfer
first_new_block = Block(block_number + 1)
first_block_iteration = target.state_transition(init_transition.new_state,
first_new_block)
assert first_block_iteration.new_state.block_number == block_number + 1
secret_reveal = ReceiveSecretReveal(factories.UNIT_SECRET, initiator)
reveal_iteration = target.state_transition(first_block_iteration.new_state,
secret_reveal)
assert reveal_iteration.new_state.from_transfer.secret == factories.UNIT_SECRET
second_new_block = Block(block_number + 2)
second_block_iteration = target.state_transition(init_transition.new_state,
second_new_block)
assert second_block_iteration.new_state.block_number == block_number + 2
nonce = 11
transferred_amount = 13
locksroot = ''
message_hash = ''
balance_proof = ReceiveBalanceProof(
from_transfer.identifier,
from_route.node_address,
nonce,
transferred_amount,
locksroot,
from_route.channel_address,
message_hash,
)
proof_iteration = target.state_transition(init_transition.new_state,
balance_proof)
assert proof_iteration.new_state is None
def balance_proof(self, message_proof):
if not isinstance(message_proof, EnvelopeMessage):
raise ValueError('proof must be an EnvelopeMessage')
balance_proof = message_proof.to_balanceproof()
balance_proof = ReceiveBalanceProof(
message_proof.identifier,
message_proof.sender,
balance_proof,
)
self.raiden.state_machine_event_handler.log_and_dispatch_by_identifier(
balance_proof.identifier,
balance_proof,
)
def balance_proof(self, proof):
if not isinstance(proof, EnvelopeMessage):
raise ValueError('proof must be an EnvelopeMessage')
balance_proof = ReceiveBalanceProof(
proof.identifier,
proof.sender,
proof.nonce,
proof.transferred_amount,
proof.locksroot,
proof.channel,
proof.message_hash,
)
self.raiden.state_machine_event_handler.log_and_dispatch_by_identifier(
balance_proof.identifier,
balance_proof,
)