def test_service_registry_random_pfs(
service_registry_address,
private_keys,
web3,
contract_manager,
):
addresses = [
to_checksum_address(privatekey_to_address(key)) for key in private_keys
]
c1_service_proxy, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
assert c1_service_proxy.service_count('latest') == 3
# Test that getting the url for each service address works
for idx, address in enumerate(addresses):
assert c1_service_proxy.get_service_url('latest', address) == urls[idx]
# Test that getting the url for a non-existing service address returns None
assert c1_service_proxy.get_service_url('latest',
to_checksum_address(HOP1)) is None
# Test that get_service_address by index works
for idx, address in enumerate(addresses):
assert c1_service_proxy.get_service_address('latest', idx) == address
# Test that getting the address for an index out of bounds returns None
assert not c1_service_proxy.get_service_address('latest', 9999)
# Test that getting a random service from the proxy works
assert get_random_service(c1_service_proxy,
'latest') in zip(urls, addresses)
def test_service_registry_set_url(service_registry_address, private_keys, web3, contract_manager):
c1_service_proxy, _ = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
with pytest.raises(BrokenPreconditionError):
c1_service_proxy.set_url("")
with pytest.raises(BrokenPreconditionError):
c1_service_proxy.set_url("raiden-network.com")
def test_check_pfs_for_production(service_registry_address, private_keys, web3,
contract_manager) -> None:
chain_id = ChainID(int(web3.net.version))
service_registry, _ = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
# Configuring an address that doesn't match the registered url should error
pfs_info = PFSInfo(
url="http://ourgivenaddress",
price=TokenAmount(0),
chain_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
payment_address=privatekey_to_address(private_keys[0]),
message="",
operator="",
version="",
user_deposit_address=privatekey_to_address(private_keys[1]),
confirmed_block_number=BlockNumber(10),
matrix_server="http://matrix.example.com",
)
with pytest.raises(RaidenError):
check_pfs_for_production(service_registry=service_registry,
pfs_info=pfs_info)
# Configuring an pfs payment address that isn't registered should error
pfs_info = PFSInfo(
url="http://foo",
price=TokenAmount(0),
chain_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
payment_address=to_canonical_address(
"0x2222222222222222222222222222222222222221"),
message="",
operator="",
version="",
user_deposit_address=privatekey_to_address(private_keys[1]),
confirmed_block_number=BlockNumber(10),
matrix_server="http://matrix.example.com",
)
with pytest.raises(RaidenError):
check_pfs_for_production(service_registry=service_registry,
pfs_info=pfs_info)
def test_service_registry_random_pfs(service_registry_address, private_keys,
web3, contract_manager):
addresses = [privatekey_to_address(key) for key in private_keys]
c1_service_proxy, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
assert c1_service_proxy.ever_made_deposits_len(BLOCK_ID_LATEST) == 3
# Test that getting the url for each service address works
for idx, address in enumerate(addresses):
assert c1_service_proxy.get_service_url(BLOCK_ID_LATEST,
address) == urls[idx]
# Test that getting the url for a non-existing service address returns None
assert c1_service_proxy.get_service_url(BLOCK_ID_LATEST, HOP1) is None
# Test that get_service_address by index works
for idx, address in enumerate(addresses):
assert c1_service_proxy.ever_made_deposits(BLOCK_ID_LATEST,
idx) == address
# Test that getting the address for an index out of bounds returns None
assert not c1_service_proxy.ever_made_deposits(BLOCK_ID_LATEST, 9999)
mock_get_pfs_info = Mock()
mock_get_pfs_info.return_value.price = 100
with patch("raiden.network.pathfinding.get_pfs_info", mock_get_pfs_info):
# Make sure that too expensive PFSes are not considered valid
assert not get_valid_pfs_url(c1_service_proxy,
0,
BLOCK_ID_LATEST,
pathfinding_max_fee=FeeAmount(99))
# ...but ones with the expected price are fine
assert (get_valid_pfs_url(
c1_service_proxy,
0,
BLOCK_ID_LATEST,
pathfinding_max_fee=FeeAmount(100)) == urls[0])
# Test that getting a random service from the proxy works
assert (get_random_pfs(c1_service_proxy,
BLOCK_ID_LATEST,
pathfinding_max_fee=FeeAmount(100)) in urls)
def test_configure_pfs(service_registry_address, private_keys, web3,
contract_manager):
chain_id = ChainID(int(web3.net.version))
service_registry, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
json_data = {
"price_info":
0,
"network_info": {
"chain_id":
chain_id,
"token_network_registry_address":
to_checksum_address(token_network_registry_address_test_default),
"user_deposit_address":
to_checksum_address(privatekey_to_address(private_keys[1])),
"confirmed_block": {
"number": 10
},
},
"message":
"This is your favorite pathfinding service",
"operator":
"John Doe",
"version":
"0.0.1",
"payment_address":
to_checksum_address(privatekey_to_address(private_keys[0])),
}
response = mocked_json_response(response_data=json_data)
# With local routing configure_pfs should raise assertion
with pytest.raises(AssertionError):
_ = configure_pfs_or_exit(
pfs_url="",
routing_mode=RoutingMode.LOCAL,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# With private routing configure_pfs should raise assertion
with pytest.raises(AssertionError):
_ = configure_pfs_or_exit(
pfs_url="",
routing_mode=RoutingMode.PRIVATE,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# Asking for auto address
# To make this deterministic we need to patch the random selection function
patch_random = patch("raiden.network.pathfinding.get_random_pfs",
return_value="http://foo")
with patch.object(requests, "get", return_value=response), patch_random:
config = configure_pfs_or_exit(
pfs_url=MATRIX_AUTO_SELECT_SERVER,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
assert config.url in urls
assert is_canonical_address(config.payment_address)
# Configuring a valid given address
given_address = "http://foo"
with patch.object(requests, "get", return_value=response):
config = configure_pfs_or_exit(
pfs_url=given_address,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
assert config.url == given_address
assert is_same_address(config.payment_address,
json_data["payment_address"])
assert config.price == json_data["price_info"]
# Bad address, should exit the program
bad_address = "http://badaddress"
with pytest.raises(RaidenError):
with patch.object(requests,
"get",
side_effect=requests.RequestException()):
# Configuring a given address
_ = configure_pfs_or_exit(
pfs_url=bad_address,
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# Addresses of token network registries of pfs and client conflict, should exit the client
response = mocked_json_response(response_data=json_data)
with pytest.raises(RaidenError):
with patch.object(requests, "get", return_value=response):
_ = configure_pfs_or_exit(
pfs_url="http://foo",
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=chain_id,
token_network_registry_address=TokenNetworkRegistryAddress(
to_canonical_address(
"0x2222222222222222222222222222222222222221")),
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
# ChainIDs of pfs and client conflict, should exit the client
response = mocked_json_response(response_data=json_data)
with pytest.raises(RaidenError):
with patch.object(requests, "get", return_value=response):
configure_pfs_or_exit(
pfs_url="http://foo",
routing_mode=RoutingMode.PFS,
service_registry=service_registry,
node_network_id=ChainID(chain_id + 1),
token_network_registry_address=
token_network_registry_address_test_default,
pathfinding_max_fee=DEFAULT_PATHFINDING_MAX_FEE,
)
def test_configure_pfs(
service_registry_address,
private_keys,
web3,
contract_manager,
):
service_proxy, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
json_data = {
'price_info': 0,
'network_info': {
'chain_id': 1,
'registry_address': '0xB9633dd9a9a71F22C933bF121d7a22008f66B908',
},
'message': 'This is your favorite pathfinding service',
'operator': 'John Doe',
'version': '0.0.1',
}
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(return_value=json_data)
# With basic routing configure pfs should return None
config = configure_pfs(
pfs_address=None,
pfs_eth_address=None,
routing_mode=RoutingMode.BASIC,
service_registry=service_proxy,
)
assert config is None
# Asking for auto address
with patch.object(requests, 'get', return_value=response):
config = configure_pfs(
pfs_address='auto',
pfs_eth_address=None,
routing_mode=RoutingMode.PFS,
service_registry=service_proxy,
)
assert config.url in urls
assert is_checksum_address(config.eth_address)
# Configuring a given address
given_address = 'http://ourgivenaddress'
given_eth_address = '0x22222222222222222222'
with patch.object(requests, 'get', return_value=response):
config = configure_pfs(
pfs_address=given_address,
pfs_eth_address=given_eth_address,
routing_mode=RoutingMode.PFS,
service_registry=service_proxy,
)
assert config.url == given_address
assert config.eth_address == given_eth_address
assert config.fee == json_data['price_info']
# Bad address, should exit the program
response = Mock()
response.configure_mock(status_code=400)
bad_address = 'http://badaddress'
pfs_eth_address = '0x22222222222222222222'
with pytest.raises(SystemExit):
with patch.object(requests,
'get',
side_effect=requests.RequestException()):
# Configuring a given address
config = configure_pfs(
pfs_address=bad_address,
pfs_eth_address=pfs_eth_address,
routing_mode=RoutingMode.PFS,
service_registry=service_proxy,
)
def test_configure_pfs(service_registry_address, private_keys, web3,
contract_manager):
service_proxy, urls = deploy_service_registry_and_set_urls(
private_keys=private_keys,
web3=web3,
contract_manager=contract_manager,
service_registry_address=service_registry_address,
)
json_data = {
"price_info": 0,
"network_info": {
"chain_id": 1,
"registry_address": "0xB9633dd9a9a71F22C933bF121d7a22008f66B908",
},
"message": "This is your favorite pathfinding service",
"operator": "John Doe",
"version": "0.0.1",
}
response = Mock()
response.configure_mock(status_code=200)
response.json = Mock(return_value=json_data)
# With basic routing configure pfs should raise assertion
with pytest.raises(AssertionError):
config = configure_pfs_or_exit(
pfs_address=None,
pfs_eth_address=None,
routing_mode=RoutingMode.BASIC,
service_registry=service_proxy,
)
# Asking for auto address
with patch.object(requests, "get", return_value=response):
config = configure_pfs_or_exit(
pfs_address="auto",
pfs_eth_address=None,
routing_mode=RoutingMode.PFS,
service_registry=service_proxy,
)
assert config.url in urls
assert is_checksum_address(config.eth_address)
# Configuring a given address
given_address = "http://ourgivenaddress"
given_eth_address = "0x22222222222222222222"
with patch.object(requests, "get", return_value=response):
config = configure_pfs_or_exit(
pfs_address=given_address,
pfs_eth_address=given_eth_address,
routing_mode=RoutingMode.PFS,
service_registry=service_proxy,
)
assert config.url == given_address
assert config.eth_address == given_eth_address
assert config.fee == json_data["price_info"]
# Bad address, should exit the program
response = Mock()
response.configure_mock(status_code=400)
bad_address = "http://badaddress"
pfs_eth_address = "0x22222222222222222222"
with pytest.raises(SystemExit):
with patch.object(requests,
"get",
side_effect=requests.RequestException()):
# Configuring a given address
config = configure_pfs_or_exit(
pfs_address=bad_address,
pfs_eth_address=pfs_eth_address,
routing_mode=RoutingMode.PFS,
service_registry=service_proxy,
)
