def test_api_channel_open_channel_invalid_input( api_server_test_instance: APIServer, token_addresses, reveal_timeout): partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] settle_timeout = TEST_SETTLE_TIMEOUT_MIN - 1 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) channel_data_obj["settle_timeout"] = str(TEST_SETTLE_TIMEOUT_MAX + 1) request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) channel_data_obj["settle_timeout"] = str(TEST_SETTLE_TIMEOUT_MAX - 1) channel_data_obj["token_address"] = to_checksum_address( factories.make_address()) request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT)
def test_get_connection_managers_info(api_server_test_instance: APIServer, token_addresses): # check that there are no registered tokens request = grequests.get( api_url_for(api_server_test_instance, "connectionsinforesource")) response = request.send().response result = get_json_response(response) assert len(result) == 0 funds = 100 token_address1 = to_checksum_address(token_addresses[0]) connect_data_obj = {"funds": funds} request = grequests.put( api_url_for(api_server_test_instance, "connectionsresource", token_address=token_address1), json=connect_data_obj, ) response = request.send().response assert_no_content_response(response) # check that there now is one registered channel manager request = grequests.get( api_url_for(api_server_test_instance, "connectionsinforesource")) response = request.send().response result = get_json_response(response) assert isinstance(result, dict) and len(result.keys()) == 1 assert token_address1 in result assert isinstance(result[token_address1], dict) assert set(result[token_address1].keys()) == { "funds", "sum_deposits", "channels" }
def test_channel_events(api_server_test_instance: APIServer, token_addresses): # let's create a new channel partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.CREATED) request = grequests.get( api_url_for( api_server_test_instance, "tokenchanneleventsresourceblockchain", token_address=token_address, from_block=str(GENESIS_BLOCK_NUMBER), )) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.OK) assert len(get_json_response(response)) > 0
def test_get_connections_info( raiden_network: List[RaidenService], api_server_test_instance: APIServer, token_addresses: List[TokenAddress], ): token_address = token_addresses[0] # Check that there are no registered tokens request = grequests.get( api_url_for(api_server_test_instance, "connectionsinforesource")) response = request.send().response result = get_json_response(response) assert len(result) == 0 # Create a channel app0 = raiden_network[0] RaidenAPI(app0).channel_open( registry_address=app0.default_registry.address, token_address=token_address, partner_address=factories.make_address(), ) # Check that there is a channel for one token, now cs_token_address = to_checksum_address(token_address) request = grequests.get( api_url_for(api_server_test_instance, "connectionsinforesource")) response = request.send().response result = get_json_response(response) assert isinstance(result, dict) and len(result.keys()) == 1 assert cs_token_address in result assert isinstance(result[cs_token_address], dict) assert set(result[cs_token_address].keys()) == {"sum_deposits", "channels"}
def test_api_channel_set_reveal_timeout( api_server_test_instance: APIServer, raiden_network: List[RaidenService], token_addresses, settle_timeout, ): app0, app1 = raiden_network token_address = token_addresses[0] partner_address = app1.address request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(reveal_timeout=0), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(reveal_timeout=settle_timeout + 1), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) reveal_timeout = int(settle_timeout / 2) request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(reveal_timeout=reveal_timeout), ) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) token_network_address = views.get_token_network_address_by_token_address( views.state_from_raiden(app0), app0.default_registry.address, token_address) assert token_network_address channel_state = views.get_channelstate_by_token_network_and_partner( chain_state=views.state_from_raiden(app0), token_network_address=token_network_address, partner_address=app1.address, ) assert channel_state assert channel_state.reveal_timeout == reveal_timeout
def test_api_channel_withdraw(api_server_test_instance: APIServer, raiden_network: List[RaidenService], token_addresses): _, app1 = raiden_network token_address = token_addresses[0] partner_address = app1.address # Withdraw a 0 amount request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="0"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # Withdraw an amount larger than balance request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="1500"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # Withdraw a valid amount request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="750"), ) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) # Withdraw same amount as before which would sum up to more than the balance request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="750"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT)
def test_get_token_network_for_token( api_server_test_instance, token_amount, token_addresses, raiden_network: List[RaidenService], contract_manager, retry_timeout, unregistered_token, ): app0 = raiden_network[0] new_token_address = unregistered_token # Wait until Raiden can start using the token contract. # Here, the block at which the contract was deployed should be confirmed by Raiden. # Therefore, until that block is received. wait_for_block( raiden=app0, block_number=BlockNumber(app0.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS + 1), retry_timeout=retry_timeout, ) # unregistered token returns 404 token_request = grequests.get( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) token_response = token_request.send().response assert_proper_response(token_response, status_code=HTTPStatus.NOT_FOUND) # register token register_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) register_response = register_request.send().response assert_proper_response(register_response, status_code=HTTPStatus.CREATED) token_network_address = get_json_response( register_response)["token_network_address"] wait_for_token_network(app0, app0.default_registry.address, new_token_address, 0.1) # now it should return the token address token_request = grequests.get( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) token_response = token_request.send().response assert_proper_response(token_response, status_code=HTTPStatus.OK) assert token_network_address == get_json_response(token_response)
def test_api_payments_with_invalid_input(api_server_test_instance: APIServer, raiden_network, token_addresses): _, app1 = raiden_network amount = 100 token_address = token_addresses[0] target_address = app1.raiden.address settle_timeout = 39 # Invalid identifier being 0 or negative request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": str(amount), "identifier": "0", "lock_timeout": str(settle_timeout) }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": str(amount), "identifier": "-1", "lock_timeout": str(settle_timeout) }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT) request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": str(amount), "identifier": str(UINT64_MAX + 1), "lock_timeout": str(settle_timeout), }, ) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.CONFLICT)
def test_api_payments_target_error(api_server_test_instance: APIServer, raiden_network, token_addresses): _, app1 = raiden_network amount = 200 identifier = 42 token_address = token_addresses[0] target_address = app1.raiden.address # stop app1 to force an error app1.stop() request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": str(amount), "identifier": str(identifier) }, ) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.CONFLICT)
def test_register_token_without_balance( api_server_test_instance, token_amount, raiden_network: List[RaidenService], contract_manager, retry_timeout, ): app0 = raiden_network[0] contract_proxy, _ = app0.rpc_client.deploy_single_contract( contract_name=CONTRACT_HUMAN_STANDARD_TOKEN, contract=contract_manager.get_contract(CONTRACT_HUMAN_STANDARD_TOKEN), constructor_parameters=(token_amount, 2, "raiden", "Rd2"), ) new_token_address = Address(to_canonical_address(contract_proxy.address)) # Wait until Raiden can start using the token contract. # Here, the block at which the contract was deployed should be confirmed by Raiden. # Therefore, until that block is received. wait_for_block( raiden=app0, block_number=BlockNumber(app0.get_block_number() + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS + 1), retry_timeout=retry_timeout, ) # Burn all the eth and then make sure we get the appropriate API error burn_eth(app0.rpc_client) poor_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) poor_response = poor_request.send().response assert_response_with_error(poor_response, HTTPStatus.PAYMENT_REQUIRED)
def test_api_testnet_token_mint(api_server_test_instance: APIServer, token_addresses): user_address = factories.make_checksum_address() token_address = token_addresses[0] url = api_url_for(api_server_test_instance, "tokensmintresource", token_address=token_address) request = grequests.post(url, json=dict(to=user_address, value=1)) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) # mint method defaults to mintFor request = grequests.post(url, json=dict(to=user_address, value=10)) response = request.send().response assert_response_with_code(response, HTTPStatus.OK) # invalid due to negative value request = grequests.post(url, json=dict(to=user_address, value=-1)) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # invalid due to invalid address request = grequests.post(url, json=dict(to=user_address[:-2], value=10)) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # trying to mint with no ETH burn_eth(api_server_test_instance.rest_api.raiden_api.raiden.rpc_client) request = grequests.post(url, json=dict(to=user_address, value=1)) response = request.send().response assert_response_with_code(response, HTTPStatus.PAYMENT_REQUIRED)
def test_api_channel_close_insufficient_eth( api_server_test_instance: APIServer, token_addresses, reveal_timeout): # let's create a new channel partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) channel_identifier = 1 json_response = get_json_response(response) expected_response = channel_data_obj.copy() expected_response.update({ "balance": str(balance), "state": ChannelState.STATE_OPENED.value, "reveal_timeout": str(reveal_timeout), "channel_identifier": str(channel_identifier), "total_deposit": "0", }) assert check_dict_nested_attrs(json_response, expected_response) # let's burn all eth and try to close the channel burn_eth(api_server_test_instance.rest_api.raiden_api.raiden.rpc_client) request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json={"state": ChannelState.STATE_CLOSED.value}, ) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) json_response = get_json_response(response) assert "insufficient ETH" in json_response["errors"]
def test_api_get_raiden_version(api_server_test_instance: APIServer): request = grequests.get( api_url_for(api_server_test_instance, "versionresource")) response = request.send().response assert_proper_response(response) raiden_version = get_system_spec()["raiden"] assert get_json_response(response) == {"version": raiden_version}
def test_api_query_our_address(api_server_test_instance: APIServer): request = grequests.get( api_url_for(api_server_test_instance, "addressresource")) response = request.send().response assert_proper_response(response) our_address = api_server_test_instance.rest_api.raiden_api.address assert get_json_response(response) == { "our_address": to_checksum_address(our_address) }
def test_api_get_node_settings(api_server_test_instance: APIServer): request = grequests.get( api_url_for(api_server_test_instance, "nodesettingsresource")) response = request.send().response assert_proper_response(response) pfs_config = api_server_test_instance.rest_api.raiden_api.raiden.config.pfs_config assert get_json_response(response) == { "pathfinding_service_address": pfs_config and pfs_config.info.url }
def test_api_payments_post_without_required_params(api_server_test_instance, token_addresses): token_address = token_addresses[0] request = grequests.post( api_url_for( api_server_test_instance, "paymentresource", ), ) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.METHOD_NOT_ALLOWED) request = grequests.post( api_url_for( api_server_test_instance, "token_paymentresource", token_address=to_checksum_address(token_address), ), ) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.METHOD_NOT_ALLOWED)
def test_api_tokens(api_server_test_instance: APIServer, blockchain_services, token_addresses): partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address1 = token_addresses[0] token_address2 = token_addresses[1] settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address1), "settle_timeout": str(settle_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address2), "settle_timeout": str(settle_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) # and now let's get the token list request = grequests.get( api_url_for(api_server_test_instance, "tokensresource")) response = request.send().response assert_proper_response(response) json_response = get_json_response(response) expected_response = [ to_checksum_address(token_address1), to_checksum_address(token_address2) ] assert set(json_response) == set(expected_response)
def test_payload_with_address_not_eip55(api_server_test_instance: APIServer): """ Provided addresses must be EIP55 encoded. """ invalid_address = "0xf696209d2ca35e6c88e5b99b7cda3abf316bed69" channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "90", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST)
def test_api_get_channel_list(api_server_test_instance: APIServer, token_addresses, reveal_timeout): partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" request = grequests.get( api_url_for(api_server_test_instance, "channelsresource")) response = request.send().response assert_proper_response(response, HTTPStatus.OK) json_response = get_json_response(response) assert json_response == [] # let's create a new channel token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) request = grequests.get( api_url_for(api_server_test_instance, "channelsresource")) response = request.send().response assert_proper_response(response, HTTPStatus.OK) json_response = get_json_response(response) channel_info = json_response[0] assert channel_info["partner_address"] == partner_address assert channel_info["token_address"] == to_checksum_address(token_address) assert channel_info["total_deposit"] == "0" assert "token_network_address" in channel_info
def test_payload_with_address_invalid_length( api_server_test_instance: APIServer): """ Encoded addresses must have the right length. """ invalid_address = "0x61c808d82a3ac53231750dadc13c777b59310b" # one char short channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "10", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST)
def test_payload_with_address_invalid_chars( api_server_test_instance: APIServer): """ Addresses cannot have invalid characters in it. """ invalid_address = "0x61c808d82a3ac53231750dadc13c777b59310bdg" # g at the end is invalid channel_data_obj = { "partner_address": invalid_address, "token_address": "0xEA674fdDe714fd979de3EdF0F56AA9716B898ec8", "settle_timeout": "10", } request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST)
def test_token_events_errors_for_unregistered_token(api_server_test_instance): request = grequests.get( api_url_for( api_server_test_instance, "tokenchanneleventsresourceblockchain", token_address="0x61C808D82A3Ac53231750daDc13c777b59310bD9", from_block="5", to_block="20", )) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.NOT_FOUND) request = grequests.get( api_url_for( api_server_test_instance, "channelblockchaineventsresource", token_address="0x61C808D82A3Ac53231750daDc13c777b59310bD9", partner_address="0x61C808D82A3Ac53231750daDc13c777b59313bD9", from_block="5", to_block="20", )) response = request.send().response assert_response_with_error(response, status_code=HTTPStatus.NOT_FOUND)
def test_api_channel_status_channel_nonexistant( api_server_test_instance: APIServer, token_addresses): partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] request = grequests.get( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, )) response = request.send().response assert_proper_response(response, HTTPStatus.NOT_FOUND) assert get_json_response(response)["errors"] == ( "Channel with partner '{}' for token '{}' could not be found.".format( to_checksum_address(partner_address), to_checksum_address(token_address)))
def test_connect_insufficient_reserve(api_server_test_instance: APIServer, token_addresses): # Burn all eth and then try to connect to a token network burn_eth(api_server_test_instance.rest_api.raiden_api.raiden.rpc_client) funds = 100 token_address1 = to_checksum_address(token_addresses[0]) connect_data_obj = {"funds": funds} request = grequests.put( api_url_for(api_server_test_instance, "connectionsresource", token_address=token_address1), json=connect_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) json_response = get_json_response(response) assert "The account balance is below the estimated amount" in json_response[ "errors"]
def test_api_get_contract_infos(api_server_test_instance: APIServer): request = grequests.get( api_url_for(api_server_test_instance, "contractsresource")) response = request.send().response assert_proper_response(response) json = get_json_response(response) assert json["contracts_version"] == CONTRACTS_VERSION for contract_name in [ "token_network_registry_address", "secret_registry_address", "service_registry_address", "user_deposit_address", "monitoring_service_address", "one_to_n_address", ]: address = json[contract_name] if address is not None: assert is_checksum_address(address)
def test_api_payments_with_secret_and_hash(api_server_test_instance: APIServer, raiden_network, token_addresses): _, app1 = raiden_network amount = 100 identifier = 42 token_address = token_addresses[0] target_address = app1.raiden.address secret = to_hex(factories.make_secret()) secret_hash = to_hex(sha256(to_bytes(hexstr=secret)).digest()) our_address = api_server_test_instance.rest_api.raiden_api.address payment = { "initiator_address": to_checksum_address(our_address), "target_address": to_checksum_address(target_address), "token_address": to_checksum_address(token_address), "amount": str(amount), "identifier": str(identifier), } request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": str(amount), "identifier": str(identifier), "secret": secret, "secret_hash": secret_hash, }, ) with watch_for_unlock_failures(*raiden_network): response = request.send().response assert_proper_response(response) json_response = get_json_response(response) assert_payment_secret_and_hash(json_response, payment) assert secret == json_response["secret"] assert secret_hash == json_response["secret_hash"]
def test_register_token_mainnet( api_server_test_instance: APIServer, token_amount, raiden_network: List[RaidenService], contract_manager, ): app0 = raiden_network[0] contract_proxy, _ = app0.rpc_client.deploy_single_contract( contract_name=CONTRACT_HUMAN_STANDARD_TOKEN, contract=contract_manager.get_contract(CONTRACT_HUMAN_STANDARD_TOKEN), constructor_parameters=(token_amount, 2, "raiden", "Rd"), ) new_token_address = Address(to_canonical_address(contract_proxy.address)) register_request = grequests.put( api_url_for( api_server_test_instance, "registertokenresource", token_address=to_checksum_address(new_token_address), )) response = register_request.send().response assert response is not None and response.status_code == HTTPStatus.NOT_IMPLEMENTED
def test_api_payments_conflicts(api_server_test_instance: APIServer, raiden_network: List[RaidenService], token_addresses): _, app1 = raiden_network token_address = token_addresses[0] target_address = app1.address payment_url = api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ) # two different transfers (different amounts) with same identifier at the same time: # payment conflict responses = grequests.map([ grequests.post(payment_url, json={ "amount": "10", "identifier": "11" }), grequests.post(payment_url, json={ "amount": "11", "identifier": "11" }), ]) assert_payment_conflict(responses) # same request sent twice, e. g. when it is retried: no conflict responses = grequests.map([ grequests.post(payment_url, json={ "amount": "10", "identifier": "73" }), grequests.post(payment_url, json={ "amount": "10", "identifier": "73" }), ]) assert all(response.status_code == HTTPStatus.OK for response in responses)
def test_api_payments_with_hash_no_secret(api_server_test_instance, raiden_network, token_addresses): _, app1 = raiden_network token_address = token_addresses[0] target_address = app1.raiden.address secret_hash = factories.make_secret_hash() request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": DEFAULT_AMOUNT, "identifier": DEFAULT_ID, "secret_hash": to_hex(secret_hash), }, ) response = request.send().response assert_proper_response(response, status_code=HTTPStatus.CONFLICT)
def test_channel_events_raiden(api_server_test_instance: APIServer, raiden_network, token_addresses): _, app1 = raiden_network amount = 100 identifier = 42 token_address = token_addresses[0] target_address = app1.raiden.address request = grequests.post( api_url_for( api_server_test_instance, "token_target_paymentresource", token_address=to_checksum_address(token_address), target_address=to_checksum_address(target_address), ), json={ "amount": str(amount), "identifier": str(identifier) }, ) response = request.send().response assert_proper_response(response)