def test_pfs_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
monkeypatch,
global_rooms,
):
"""
Test that RaidenService sends UpdatePFS messages to global
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
"global_rooms": global_rooms, # FIXME: #3735
"retries_before_backoff": retries_before_backoff,
"retry_interval": retry_interval,
"server": local_matrix_servers[0],
"server_name": local_matrix_servers[0].netloc,
"available_servers": [local_matrix_servers[0]],
"private_rooms": private_rooms,
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(raiden_service, raiden_service.message_handler, None)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
update_path_finding_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
transport.stop()
transport.get()
def test_monitoring_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
):
"""
Test that RaidenService sends RequestMonitoring messages to global
MONITORING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
'global_rooms': ['discovery', MONITORING_BROADCASTING_ROOM],
'retries_before_backoff':
retries_before_backoff,
'retry_interval':
retry_interval,
'server':
local_matrix_servers[0],
'server_name':
local_matrix_servers[0].netloc,
'available_servers': [local_matrix_servers[0]],
'private_rooms':
private_rooms,
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
ms_room_name = make_room_alias(transport.network_id,
MONITORING_BROADCASTING_ROOM)
ms_room = transport._global_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = make_balance_proof(signer=LocalSigner(HOP1_KEY), amount=1)
update_monitoring_service_from_balance_proof(
raiden_service,
balance_proof,
)
gevent.idle()
assert ms_room.send_text.call_count == 1
transport.stop()
transport.get()
def test_pfs_broadcast_messages(
local_matrix_servers,
retry_interval_initial,
retry_interval_max,
retries_before_backoff,
monkeypatch,
broadcast_rooms,
route_mode,
):
"""
Test that RaidenService broadcasts PFSCapacityUpdate messages to
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport(
config=MatrixTransportConfig(
broadcast_rooms=broadcast_rooms,
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_servers[0],
available_servers=[local_matrix_servers[0]],
),
environment=Environment.DEVELOPMENT,
)
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config.services.monitoring_enabled = True
raiden_service.routing_mode = route_mode
transport.start(raiden_service, [], None)
pfs_room_name = make_room_alias(transport.chain_id, PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._broadcast_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
# send PFSCapacityUpdate
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
send_pfs_update(raiden=raiden_service, canonical_identifier=balance_proof.canonical_identifier)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
# send PFSFeeUpdate
channel_state = factories.create(factories.NettingChannelStateProperties())
fee_update = PFSFeeUpdate.from_channel_state(channel_state)
fee_update.sign(raiden_service.signer)
raiden_service.transport.broadcast(PATH_FINDING_BROADCASTING_ROOM, fee_update)
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 2:
gevent.idle()
assert pfs_room.send_text.call_count == 2
msg_data = json.loads(pfs_room.send_text.call_args[0][0])
assert msg_data["type"] == "PFSFeeUpdate"
transport.stop()
transport.greenlet.get()
def test_monitoring_broadcast_messages(
local_matrix_servers,
retry_interval_initial,
retry_interval_max,
retries_before_backoff,
monkeypatch,
broadcast_rooms,
):
"""
Test that RaidenService broadcast RequestMonitoring messages to
MONITORING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport(
config=MatrixTransportConfig(
broadcast_rooms=broadcast_rooms + [MONITORING_BROADCASTING_ROOM],
retries_before_backoff=retries_before_backoff,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
server=local_matrix_servers[0],
available_servers=[local_matrix_servers[0]],
),
environment=Environment.DEVELOPMENT,
)
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = RaidenConfig(
chain_id=1234,
environment_type=Environment.DEVELOPMENT,
services=ServiceConfig(monitoring_enabled=True),
)
transport.start(raiden_service, [], None)
ms_room_name = make_room_alias(transport.chain_id, MONITORING_BROADCASTING_ROOM)
ms_room = transport._broadcast_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
monkeypatch.setattr(raiden.transfer.channel, "get_balance", lambda *a, **kw: 123)
raiden_service.user_deposit.effective_balance.return_value = MONITORING_REWARD
update_monitoring_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof,
non_closing_participant=HOP1,
)
gevent.idle()
with gevent.Timeout(2):
while ms_room.send_text.call_count < 1:
gevent.idle()
assert ms_room.send_text.call_count == 1
transport.stop()
transport.greenlet.get()
def test_pfs_global_messages(
matrix_transports,
monkeypatch,
):
"""
Test that `update_pfs` from `RaidenEventHandler` sends balance proof updates to the global
PATH_FINDING_BROADCASTING_ROOM room on Send($BalanceProof)* events, i.e. events, that send
a new balance proof to the channel partner.
"""
transport = matrix_transports[0]
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
# create mock events that should trigger a send
lock = make_lock()
hash_time_lock = HashTimeLockState(lock.amount, lock.expiration,
lock.secrethash)
def make_unsigned_balance_proof(nonce):
return BalanceProofUnsignedState.from_dict(
make_balance_proof(nonce=nonce,
signer=LocalSigner(HOP1_KEY),
amount=1).to_dict(), )
transfer1 = LockedTransferUnsignedState(
balance_proof=make_unsigned_balance_proof(nonce=1),
payment_identifier=1,
token=b'1',
lock=hash_time_lock,
target=HOP1,
initiator=HOP1,
)
transfer2 = LockedTransferUnsignedState(
balance_proof=make_unsigned_balance_proof(nonce=2),
payment_identifier=1,
token=b'1',
lock=hash_time_lock,
target=HOP1,
initiator=HOP1,
)
send_balance_proof_events = [
SendLockedTransfer(HOP1, 1, 1, transfer1),
SendRefundTransfer(HOP1, 1, 1, transfer2),
SendBalanceProof(HOP1, 1, 1, 1, b'1', b'x' * 32,
make_unsigned_balance_proof(nonce=3)),
SendLockExpired(HOP1, 1, make_unsigned_balance_proof(nonce=4),
b'x' * 32),
]
for num, event in enumerate(send_balance_proof_events):
assert event.balance_proof.nonce == num + 1
# make sure we cover all configured event types
assert all(event in [type(event) for event in send_balance_proof_events]
for event in SEND_BALANCE_PROOF_EVENTS)
event_handler = raiden_event_handler.RaidenEventHandler()
# let our mock objects pass validation
channelstate_mock = Mock()
channelstate_mock.reveal_timeout = 1
monkeypatch.setattr(
raiden_event_handler,
'get_channelstate_by_token_network_and_partner',
lambda *args, **kwargs: channelstate_mock,
)
monkeypatch.setattr(raiden_event_handler, 'state_from_raiden',
lambda *args, **kwargs: 1)
monkeypatch.setattr(event_handler, 'handle_send_lockedtransfer',
lambda *args, **kwargs: 1)
monkeypatch.setattr(event_handler, 'handle_send_refundtransfer',
lambda *args, **kwargs: 1)
# handle the events
for event in send_balance_proof_events:
event_handler.on_raiden_event(
raiden_service,
event,
)
gevent.idle()
# ensure all events triggered a send for their respective balance_proof
# matrix transport may concatenate multiple messages send in one interval
assert pfs_room.send_text.call_count >= 1
concatenated_call_args = ' '.join(
str(arg) for arg in pfs_room.send_text.call_args_list)
assert all(f'"nonce": {i + 1}' in concatenated_call_args
for i in range(len(SEND_BALANCE_PROOF_EVENTS)))
transport.stop()
transport.get()
def test_pfs_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
monkeypatch,
global_rooms,
route_mode,
):
"""
Test that RaidenService sends PFSCapacityUpdate messages to global
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
"global_rooms":
global_rooms + [PATH_FINDING_BROADCASTING_ROOM],
"retries_before_backoff":
retries_before_backoff,
"retry_interval":
retry_interval,
"server":
local_matrix_servers[0],
"server_name":
local_matrix_servers[0].netloc,
"available_servers": [local_matrix_servers[0]],
"private_rooms":
private_rooms,
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
raiden_service.routing_mode = route_mode
transport.start(raiden_service, raiden_service.message_handler, None)
pfs_room_name = make_room_alias(transport.chain_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
# send PFSCapacityUpdate
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
send_pfs_update(raiden=raiden_service,
canonical_identifier=balance_proof.canonical_identifier)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
# send PFSFeeUpdate
channel_state = factories.create(factories.NettingChannelStateProperties())
fee_update = PFSFeeUpdate.from_channel_state(channel_state)
fee_update.sign(raiden_service.signer)
raiden_service.transport.send_global(PATH_FINDING_BROADCASTING_ROOM,
fee_update)
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 2:
gevent.idle()
assert pfs_room.send_text.call_count == 2
msg_data = json.loads(pfs_room.send_text.call_args[0][0])
assert msg_data["type"] == "PFSFeeUpdate"
transport.stop()
transport.get()
def test_monitoring_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
monkeypatch,
global_rooms,
):
"""
Test that RaidenService sends RequestMonitoring messages to global
MONITORING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
"global_rooms":
global_rooms + [MONITORING_BROADCASTING_ROOM],
"retries_before_backoff":
retries_before_backoff,
"retry_interval":
retry_interval,
"server":
local_matrix_servers[0],
"server_name":
local_matrix_servers[0].netloc,
"available_servers": [local_matrix_servers[0]],
"private_rooms":
private_rooms,
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(raiden_service, raiden_service.message_handler, None)
ms_room_name = make_room_alias(transport.chain_id,
MONITORING_BROADCASTING_ROOM)
ms_room = transport._global_rooms.get(ms_room_name)
assert isinstance(ms_room, Room)
ms_room.send_text = MagicMock(spec=ms_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = factories.create(HOP1_BALANCE_PROOF)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
"get_channelstate_by_canonical_identifier",
lambda *a, **kw: channel_state,
)
monkeypatch.setattr(raiden.transfer.channel, "get_balance",
lambda *a, **kw: 123)
raiden_service.user_deposit.effective_balance.return_value = MONITORING_REWARD
update_monitoring_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof,
non_closing_participant=HOP1,
)
gevent.idle()
with gevent.Timeout(2):
while ms_room.send_text.call_count < 1:
gevent.idle()
assert ms_room.send_text.call_count == 1
transport.stop()
transport.get()
def test_pfs_global_messages(
local_matrix_servers,
private_rooms,
retry_interval,
retries_before_backoff,
monkeypatch,
):
"""
Test that RaidenService sends UpdatePFS messages to global
PATH_FINDING_BROADCASTING_ROOM room on newly received balance proofs.
"""
transport = MatrixTransport({
'global_rooms': ['discovery', PATH_FINDING_BROADCASTING_ROOM],
'retries_before_backoff':
retries_before_backoff,
'retry_interval':
retry_interval,
'server':
local_matrix_servers[0],
'server_name':
local_matrix_servers[0].netloc,
'available_servers': [local_matrix_servers[0]],
'private_rooms':
private_rooms,
})
transport._client.api.retry_timeout = 0
transport._send_raw = MagicMock()
raiden_service = MockRaidenService(None)
raiden_service.config = dict(services=dict(monitoring_enabled=True))
transport.start(
raiden_service,
raiden_service.message_handler,
None,
)
pfs_room_name = make_room_alias(transport.network_id,
PATH_FINDING_BROADCASTING_ROOM)
pfs_room = transport._global_rooms.get(pfs_room_name)
assert isinstance(pfs_room, Room)
pfs_room.send_text = MagicMock(spec=pfs_room.send_text)
raiden_service.transport = transport
transport.log = MagicMock()
balance_proof = make_balance_proof(signer=LocalSigner(HOP1_KEY), amount=1)
channel_state = make_channel_state()
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
monkeypatch.setattr(
raiden.transfer.views,
'get_channelstate_by_canonical_identifier',
lambda *a, **kw: channel_state,
)
update_path_finding_service_from_balance_proof(
raiden=raiden_service,
chain_state=None,
new_balance_proof=balance_proof,
)
gevent.idle()
with gevent.Timeout(2):
while pfs_room.send_text.call_count < 1:
gevent.idle()
assert pfs_room.send_text.call_count == 1
transport.stop()
transport.get()
