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, )