def test_api_open_close_and_settle_channel(api_backend, api_test_context, api_raiden_service): # let's create a new channel partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 channel_data_obj = { 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout } request = grequests.put(api_url_for(api_backend, 'channelsresource'), json=channel_data_obj) response = request.send().response balance = 0 assert_proper_response(response) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # let's close the channel request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json={'state': CHANNEL_STATE_CLOSED}) response = request.send().response assert_proper_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'state': CHANNEL_STATE_CLOSED, 'balance': balance } assert response.json() == expected_response # let's settle the channel request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json={'state': CHANNEL_STATE_SETTLED}) response = request.send().response assert_proper_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'state': CHANNEL_STATE_SETTLED, 'balance': balance } assert response.json() == expected_response
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 patch(self, url, data=None, **kwargs): """HTTP PATCH Method.""" if data is not None: kwargs['data'] = data kwargs['auth'] = self.auth req = grequests.patch(url, **kwargs) return self._run(req)
def test_api_open_close_and_settle_channel( api_backend, 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': settle_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['reveal_timeout'] = reveal_timeout channel_identifier = data_encoder( calculate_channel_identifier( api_backend[1].raiden_api.raiden.address, to_canonical_address(partner_address), )) expected_response['channel_identifier'] = channel_identifier assert response == expected_response # let's close the channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json={'state': CHANNEL_STATE_CLOSED}, ) response = request.send().response assert_proper_response(response) expected_response = { 'channel_identifier': channel_identifier, 'partner_address': partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_CLOSED, 'balance': balance, } assert response.json() == expected_response
def test_api_open_close_and_settle_channel( api_backend, 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': settle_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['reveal_timeout'] = reveal_timeout expected_response['channel_identifier'] = dicts_are_equal.IGNORE_VALUE expected_response[ 'token_network_identifier'] = dicts_are_equal.IGNORE_VALUE assert dicts_are_equal(response, expected_response) token_network_identifier = response['token_network_identifier'] # let's close the channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json={'state': CHANNEL_STATE_CLOSED}, ) response = request.send().response assert_proper_response(response) expected_response = { 'token_network_identifier': token_network_identifier, 'channel_identifier': dicts_are_equal.IGNORE_VALUE, 'partner_address': partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_CLOSED, 'balance': balance, } assert dicts_are_equal(response.json(), expected_response)
def test_api_open_close_and_settle_channel( api_backend, 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': settle_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['reveal_timeout'] = reveal_timeout expected_response['channel_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response['token_network_identifier'] = assert_dicts_are_equal.IGNORE_VALUE assert_dicts_are_equal(response, expected_response) token_network_identifier = response['token_network_identifier'] # let's close the channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json={'state': CHANNEL_STATE_CLOSED}, ) response = request.send().response assert_proper_response(response) expected_response = { 'token_network_identifier': token_network_identifier, 'channel_identifier': assert_dicts_are_equal.IGNORE_VALUE, 'partner_address': partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_CLOSED, 'balance': balance, } assert_dicts_are_equal(response.json(), expected_response)
def test_api_open_close_and_settle_channel( api_backend, 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': settle_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['reveal_timeout'] = reveal_timeout # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # let's close the channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address, ), json={'state': CHANNEL_STATE_CLOSED}, ) response = request.send().response assert_proper_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_CLOSED, 'balance': balance, } assert response.json() == expected_response
def test_api_close_insufficient_eth( api_backend, 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': settle_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) channel_identifier = 1 response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['reveal_timeout'] = reveal_timeout expected_response['channel_identifier'] = channel_identifier expected_response[ 'token_network_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response['total_deposit'] = 0 assert_dicts_are_equal(response, expected_response) # let's burn all eth and try to close the channel api_server, _ = api_backend burn_all_eth(api_server.rest_api.raiden_api.raiden) request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json={'state': CHANNEL_STATE_CLOSED}, ) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) response = response.json() assert 'Insufficient ETH' in response['errors']
def test_url_with_invalid_address(rest_api_port_number, api_backend): """ Addresses require the leading 0x in the urls. """ url_without_prefix = ( 'http://localhost:{port}/api/1/' 'channels/ea674fdde714fd979de3edf0f56aa9716b898ec8').format( port=rest_api_port_number) request = grequests.patch(url_without_prefix, json=dict(state='CHANNEL_STATE_SETTLED')) response = request.send().response assert_response_with_code(response, http.client.NOT_FOUND)
def test_api_close_insufficient_eth( api_backend, 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': settle_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['reveal_timeout'] = reveal_timeout expected_response['channel_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response['token_network_identifier'] = assert_dicts_are_equal.IGNORE_VALUE assert_dicts_are_equal(response, expected_response) # let's burn all eth and try to close the channel api_server, _ = api_backend burn_all_eth(api_server.rest_api.raiden_api.raiden) request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json={'state': CHANNEL_STATE_CLOSED}, ) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) response = response.json() assert 'Insufficient ETH' in response['errors']
def test_url_with_invalid_address(rest_api_port_number, api_backend): """ Addresses require the leading 0x in the urls. """ url_without_prefix = ( 'http://localhost:{port}/api/1/' 'channels/ea674fdde714fd979de3edf0f56aa9716b898ec8' ).format(port=rest_api_port_number) request = grequests.patch( url_without_prefix, json=dict(state='CHANNEL_STATE_SETTLED') ) response = request.send().response assert_response_with_code(response, HTTPStatus.NOT_FOUND)
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 run_requests(self, requests): rs = [] for theRequest in requests: method = theRequest["method"] url = self.request.url_root.rstrip("/") + theRequest["url"] if method == "GET": rs.append(grequests.get(url)) if method == "DELETE": rs.append(grequests.delete(url)) if method == "OPTIONS": rs.append(grequests.options(url)) if method == "POST": rs.append(grequests.post(url, json=theRequest)) if method == "PATCH": rs.append(grequests.patch(url, json=theRequest)) return grequests.map(rs)
def set_status(status): async_list=[] # Update Backend data="{\"occupied\":" + str(status).lower() + "}" headers={'content-type': 'application/json'} room = grequests.patch(url="https://iothack.me/v1/room/5adbcf8c96d0713ca46038e1", headers=headers, data=data, verify=False) async_list.append(room) # Update Lights server lightURLS={"True":"https://maker.ifttt.com/trigger/room_in_use/with/key/bqxtTWTzxbTA50nGUi0rmM", "False":"https://maker.ifttt.com/trigger/room_not_in_use/with/key/bqxtTWTzxbTA50nGUi0rmM"} light = grequests.post(lightURLS[str(status)]) async_list.append(light) # Perform both backend and lights requests concurrently try: grequests.map(async_list) except: print "Error"
def send_post_request(url, credentials, params, patch=False, async_request=False): """ Sends a POST request to the given url. Args: url (str): The url to call. credentials (IntegrationCredentials): Object containing any authentication credentials. params (dict): The data to be sent. Returns: response (Response): Object containing the response information. """ headers = {'Authorization': 'Bearer %s' % credentials.access_token} if async_request: # For some reason Celery/Flower stops working when placing this with the other imports. # Importing it here seems to work fine. import grequests if patch: calls = (grequests.patch(url, headers=headers, json=params) for url in [url]) else: calls = (grequests.post(url, headers=headers, json=params) for url in [url]) try: response = grequests.map(calls)[0] except: pass else: if patch: response = requests.patch(url, headers=headers, json=params) else: response = requests.post(url, headers=headers, json=params) return response
def test_payload_with_invalid_addresses(api_server_test_instance: APIServer): """ Addresses require leading 0x in the payload. """ invalid_address = "61c808d82a3ac53231750dadc13c777b59310bd9" 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) url_without_prefix = ( "http://localhost:{port}/api/v1/channels/ea674fdde714fd979de3edf0f56aa9716b898ec8" ).format(port=api_server_test_instance.config.port) request = grequests.patch( url_without_prefix, json=dict(state=ChannelState.STATE_SETTLED.value)) response = request.send().response assert_response_with_code(response, HTTPStatus.NOT_FOUND)
def test_api_channel_state_change_errors(api_backend, api_test_context, api_raiden_service): # let's create a new channel partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 reveal_timeout = 30 channel_data_obj = { 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put(api_url_for(api_backend, 'channelsresource'), json=channel_data_obj) response = request.send().response assert_proper_response(response, http.client.CREATED) response = response.json() channel_address = response['channel_address'] # let's try to settle the channel (we are bad!) request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(state=CHANNEL_STATE_SETTLED)) response = request.send().response assert_response_with_error(response, http.client.CONFLICT) # let's try to set a random state request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(state='inlimbo')) response = request.send().response assert_response_with_error(response, http.client.BAD_REQUEST) # let's try to set both new state and balance request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(state=CHANNEL_STATE_CLOSED, balance=200)) response = request.send().response assert_response_with_error(response, http.client.CONFLICT) # let's try to path with no arguments request = grequests.patch( api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), ) response = request.send().response assert_response_with_error(response, http.client.BAD_REQUEST) # ok now let's close and settle for real request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(state=CHANNEL_STATE_CLOSED)) response = request.send().response assert_proper_response(response) request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(state=CHANNEL_STATE_SETTLED)) response = request.send().response assert_proper_response(response) # let's try to deposit to a settled channel request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(balance=500)) response = request.send().response assert_response_with_error(response, http.client.CONFLICT) # and now let's try to settle again request = grequests.patch(api_url_for(api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address), json=dict(state=CHANNEL_STATE_SETTLED)) response = request.send().response assert_response_with_error(response, http.client.CONFLICT)
def test_api_open_and_deposit_channel( api_backend, token_addresses, reveal_timeout, ): # let's create a new channel first_partner_address = '0x61C808D82A3Ac53231750daDc13c777b59310bD9' token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = 0 expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response first_channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # now let's open a channel and make a deposit too second_partner_address = '0x29FA6cf0Cce24582a9B20DB94Be4B6E017896038' balance = 100 channel_data_obj = { 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': balance, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response expected_response['channel_address'] = response['channel_address'] second_channel_address = response['channel_address'] assert response == expected_response # let's deposit on the first channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=first_channel_address, ), json={'balance': balance}, ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_address': first_channel_address, 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, } assert response == expected_response # finally let's try querying for the second channel request = grequests.get( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=second_channel_address, ), ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_address': second_channel_address, 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, } assert response == expected_response
def test_api_channel_open_close_and_settle(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) token_network_address = json_response["token_network_address"] # let's close the channel 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) expected_response = { "token_network_address": token_network_address, "channel_identifier": str(channel_identifier), "partner_address": partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "state": ChannelState.STATE_CLOSED.value, "balance": str(balance), "total_deposit": str(balance), } assert check_dict_nested_attrs(get_json_response(response), expected_response) # try closing the channel again 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}, ) # Closing the channel again should not work response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # Try sending a payment when channel is closed 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(partner_address), ), json={"amount": "1"}, ) # Payment should not work since channel is closing response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # Try to create channel with the same partner again before previous channnel settles request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) # Channel exists and is currently being settled so API request to open channel should fail response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT)
def test_api_channel_state_change_errors( api_backend, api_test_context, api_raiden_service): # let's create a new channel partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 channel_data_obj = { 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response assert_proper_response(response) response = decode_response(response) channel_address = response['channel_address'] # let's try to settle the channel (we are bad!) request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': CHANNEL_STATE_SETTLED} ) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT # let's try to set a random state request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': 'inlimbo'} ) response = request.send().response assert response is not None and response.status_code == httplib.BAD_REQUEST # let's try to set both new state and balance request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': CHANNEL_STATE_CLOSED, 'balance': 200} ) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT # let's try to path with no arguments request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), ) response = request.send().response assert response is not None and response.status_code == httplib.BAD_REQUEST # ok now let's close and settle for real request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': CHANNEL_STATE_CLOSED} ) response = request.send().response assert_proper_response(response) request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': CHANNEL_STATE_SETTLED} ) response = request.send().response assert_proper_response(response) # let's try to deposit to a settled channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'balance': 500} ) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT # and now let's try to settle again request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': CHANNEL_STATE_SETTLED} ) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT
def test_api_open_and_deposit_channel( api_backend, token_addresses, reveal_timeout, ): # let's create a new channel first_partner_address = '0x61C808D82A3Ac53231750daDc13c777b59310bD9' token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = 0 expected_response['state'] = CHANNEL_STATE_OPENED expected_response[ 'channel_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response[ 'token_network_identifier'] = assert_dicts_are_equal.IGNORE_VALUE assert_dicts_are_equal(response, expected_response) token_network_identifier = response['token_network_identifier'] # now let's open a channel and make a deposit too second_partner_address = '0x29FA6cf0Cce24582a9B20DB94Be4B6E017896038' balance = 100 channel_data_obj = { 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': balance, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response[ 'channel_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response['token_network_identifier'] = token_network_identifier assert_dicts_are_equal(response, expected_response) # assert depositing negative amount fails request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=first_partner_address, ), json={'total_deposit': -1000}, ) response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # let's deposit on the first channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=first_partner_address, ), json={'total_deposit': balance}, ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_identifier': assert_dicts_are_equal.IGNORE_VALUE, 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, 'token_network_identifier': token_network_identifier, } assert_dicts_are_equal(response, expected_response) # let's try querying for the second channel request = grequests.get( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=second_partner_address, ), ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_identifier': assert_dicts_are_equal.IGNORE_VALUE, 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, 'token_network_identifier': token_network_identifier, } assert_dicts_are_equal(response, expected_response) # finally let's burn all eth and try to open another channel api_server, _ = api_backend burn_all_eth(api_server.rest_api.raiden_api.raiden) channel_data_obj = { 'partner_address': '0xf3AF96F89b3d7CdcBE0C083690A28185Feb0b3CE', 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': 1, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) response = response.json() assert 'The account balance is below the estimated amount' in response[ 'errors']
def test_api_open_and_deposit_channel( api_backend, token_addresses, reveal_timeout, ): # let's create a new channel first_partner_address = '0x61C808D82A3Ac53231750daDc13c777b59310bD9' token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = 0 expected_response['state'] = CHANNEL_STATE_OPENED expected_response['channel_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response['token_network_identifier'] = assert_dicts_are_equal.IGNORE_VALUE assert_dicts_are_equal(response, expected_response) token_network_identifier = response['token_network_identifier'] # now let's open a channel and make a deposit too second_partner_address = '0x29FA6cf0Cce24582a9B20DB94Be4B6E017896038' balance = 100 channel_data_obj = { 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': balance, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED expected_response['channel_identifier'] = assert_dicts_are_equal.IGNORE_VALUE expected_response['token_network_identifier'] = token_network_identifier assert_dicts_are_equal(response, expected_response) # let's deposit on the first channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=first_partner_address, ), json={'total_deposit': balance}, ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_identifier': assert_dicts_are_equal.IGNORE_VALUE, 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, 'token_network_identifier': token_network_identifier, } assert_dicts_are_equal(response, expected_response) # let's try querying for the second channel request = grequests.get( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=second_partner_address, ), ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_identifier': assert_dicts_are_equal.IGNORE_VALUE, 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, 'token_network_identifier': token_network_identifier, } assert_dicts_are_equal(response, expected_response) # finally let's burn all eth and try to open another channel api_server, _ = api_backend burn_all_eth(api_server.rest_api.raiden_api.raiden) channel_data_obj = { 'partner_address': '0xf3AF96F89b3d7CdcBE0C083690A28185Feb0b3CE', 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': 1, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.PAYMENT_REQUIRED) response = response.json() assert 'Insufficient ETH' in response['errors']
def test_api_open_and_deposit_channel( api_backend, api_test_context, api_raiden_service): # let's create a new channel first_partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 reveal_timeout = 30 channel_data_obj = { 'partner_address': first_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = 0 expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response first_channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # now let's open a channel and make a deposit too second_partner_address = '0x29fa6cf0cce24582a9b20db94be4b6e017896038' balance = 100 channel_data_obj = { 'partner_address': second_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': balance } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response expected_response['channel_address'] = response['channel_address'] second_channel_address = response['channel_address'] assert response == expected_response # let's deposit on the first channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=first_channel_address ), json={'balance': balance} ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_address': first_channel_address, 'partner_address': first_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance } assert response == expected_response # finally let's try querying for the second channel request = grequests.get( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=second_channel_address ) ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_address': second_channel_address, 'partner_address': second_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance } assert response == expected_response
sub_directory3 = api.add_sub_directory_to_drive( drive['pk'], { 'title': 'Third', 'parent_directory': sub_directory2['pk'] }) print("sub_directory3_pk=", sub_directory3['pk']) reqs = [] for i in range(1, 10): reqs.append( # update sub dir 1 grequests.patch( base_url + "/drives/{drive_pk}/sub_directories/{directory_pk}/".format( drive_pk=drive['pk'], directory_pk=sub_directory1['pk']), data={'title': 'asdf'}, headers=headers)) reqs.append( # update sub dir 2 grequests.patch( base_url + "/drives/{drive_pk}/sub_directories/{directory_pk}/".format( drive_pk=drive['pk'], directory_pk=sub_directory3['pk']), data={'parent_directory': sub_directory2['pk']}, headers=headers)) grequests.map(reqs, exception_handler=exception_handler)
def test_api_channel_open_and_deposit(api_server_test_instance: APIServer, token_addresses, reveal_timeout): first_partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] token_address_hex = to_checksum_address(token_address) settle_timeout = 1650 channel_data_obj = { "partner_address": first_partner_address, "token_address": token_address_hex, "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), } # First let's try to create channel with the null address and see error is handled channel_data_obj["partner_address"] = NULL_ADDRESS_HEX 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.BAD_REQUEST) # now let's really create a new channel channel_data_obj["partner_address"] = first_partner_address 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) first_channel_id = 1 json_response = get_json_response(response) expected_response = channel_data_obj.copy() expected_response.update({ "balance": "0", "state": ChannelState.STATE_OPENED.value, "channel_identifier": "1", "total_deposit": "0", }) assert check_dict_nested_attrs(json_response, expected_response) token_network_address = json_response["token_network_address"] # Now let's try to open the same channel again, because it is possible for # the participants to race on the channel creation, this is not considered # an error. request = grequests.put(api_url_for(api_server_test_instance, "channelsresource"), json=channel_data_obj) response = request.send().response assert_proper_response(response, HTTPStatus.OK) json_response = get_json_response(response) assert check_dict_nested_attrs(json_response, expected_response) # now let's open a channel and make a deposit too second_partner_address = "0x29FA6cf0Cce24582a9B20DB94Be4B6E017896038" total_deposit = 100 channel_data_obj = { "partner_address": second_partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "total_deposit": str(total_deposit), } 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) second_channel_id = 2 json_response = get_json_response(response) expected_response = channel_data_obj.copy() expected_response.update({ "balance": str(total_deposit), "state": ChannelState.STATE_OPENED.value, "channel_identifier": str(second_channel_id), "token_network_address": token_network_address, "total_deposit": str(total_deposit), }) assert check_dict_nested_attrs(json_response, expected_response) # assert depositing again with less than the initial deposit returns 409 request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=second_partner_address, ), json={"total_deposit": "99"}, ) response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # assert depositing negative amount fails request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=first_partner_address, ), json={"total_deposit": "-1000"}, ) response = request.send().response assert_proper_response(response, HTTPStatus.CONFLICT) # let's deposit on the first channel request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=first_partner_address, ), json={"total_deposit": str(total_deposit)}, ) response = request.send().response assert_proper_response(response) json_response = get_json_response(response) expected_response = { "channel_identifier": str(first_channel_id), "partner_address": first_partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "state": ChannelState.STATE_OPENED.value, "balance": str(total_deposit), "total_deposit": str(total_deposit), "token_network_address": token_network_address, } assert check_dict_nested_attrs(json_response, expected_response) # let's try querying for the second channel request = grequests.get( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=second_partner_address, )) response = request.send().response assert_proper_response(response) json_response = get_json_response(response) expected_response = { "channel_identifier": str(second_channel_id), "partner_address": second_partner_address, "token_address": to_checksum_address(token_address), "settle_timeout": str(settle_timeout), "reveal_timeout": str(reveal_timeout), "state": ChannelState.STATE_OPENED.value, "balance": str(total_deposit), "total_deposit": str(total_deposit), "token_network_address": token_network_address, } assert check_dict_nested_attrs(json_response, expected_response) # finally let's burn all eth and try to open another channel burn_eth(api_server_test_instance.rest_api.raiden_api.raiden.rpc_client) channel_data_obj = { "partner_address": "0xf3AF96F89b3d7CdcBE0C083690A28185Feb0b3CE", "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.PAYMENT_REQUIRED) json_response = get_json_response(response) assert "The account balance is below the estimated amount" in json_response[ "errors"]
def test_api_channel_state_change_errors(api_server_test_instance: APIServer, token_addresses, reveal_timeout): 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), "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) # let's try to set a random state request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state="inlimbo"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # let's try to set both new state and total_deposit request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value, total_deposit="200"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both new state and total_withdraw request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value, total_withdraw="200"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both total deposit and total_withdraw request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit="500", total_withdraw="200"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both new state and reveal_timeout request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value, reveal_timeout="50"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both total_deposit and reveal_timeout request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit="500", reveal_timeout="50"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set both total_withdraw and reveal_timeout request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_withdraw="500", reveal_timeout="50"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to patch with no arguments request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, )) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # ok now let's close and settle for real request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(state=ChannelState.STATE_CLOSED.value), ) response = request.send().response assert_proper_response(response) # let's try to deposit to a settled channel request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit="500"), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT)
def test_api_channel_state_change_errors( api_backend, token_addresses, reveal_timeout, ): 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': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) # let's try to set a random state request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json=dict(state='inlimbo'), ) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # let's try to set both new state and balance request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json=dict(state=CHANNEL_STATE_CLOSED, total_deposit=200), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to patch with no arguments request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), ) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # ok now let's close and settle for real request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json=dict(state=CHANNEL_STATE_CLOSED), ) response = request.send().response assert_proper_response(response) # let's try to deposit to a settled channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=partner_address, ), json=dict(total_deposit=500), ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT)
def patch(self, url, data=None, **kwargs): if data is not None: kwargs['data'] = data kwargs['auth'] = self.auth return grequests.map([grequests.patch(url, **kwargs)])[0]
def test_api_open_close_and_settle_channel( api_backend, api_test_context, api_raiden_service): # let's create a new channel partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 reveal_timeout = DEFAULT_REVEAL_TIMEOUT channel_data_obj = { 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response balance = 0 assert_proper_response(response, status_code=HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED # reveal_timeout not specified, expect it to be the default expected_response['reveal_timeout'] = reveal_timeout # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # let's close the channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json={'state': CHANNEL_STATE_CLOSED} ) response = request.send().response assert_proper_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_CLOSED, 'balance': balance } assert response.json() == expected_response # let's settle the channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state=CHANNEL_STATE_SETTLED) ) response = request.send().response assert_proper_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_SETTLED, 'balance': balance } assert response.json() == expected_response
def test_api_open_and_deposit_channel( api_backend, token_addresses, reveal_timeout, ): # let's create a new channel first_partner_address = '0x61C808D82A3Ac53231750daDc13c777b59310bD9' token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = 0 expected_response['state'] = CHANNEL_STATE_OPENED first_channel_identifier = data_encoder( calculate_channel_identifier( api_backend[1].raiden_api.raiden.address, to_canonical_address(first_partner_address), )) expected_response['channel_identifier'] = first_channel_identifier assert response == expected_response # now let's open a channel and make a deposit too second_partner_address = '0x29FA6cf0Cce24582a9B20DB94Be4B6E017896038' balance = 100 channel_data_obj = { 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'balance': balance, } request = grequests.put( api_url_for( api_backend, 'channelsresource', ), json=channel_data_obj, ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED second_channel_identifier = data_encoder( calculate_channel_identifier( api_backend[1].raiden_api.raiden.address, to_canonical_address(second_partner_address), )) expected_response['channel_identifier'] = second_channel_identifier assert response == expected_response # let's deposit on the first channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=first_partner_address, ), json={'total_deposit': balance}, ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_identifier': first_channel_identifier, 'partner_address': first_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, } assert response == expected_response # finally let's try querying for the second channel request = grequests.get( api_url_for( api_backend, 'channelsresourcebytokenandpartneraddress', token_address=token_address, partner_address=second_partner_address, ), ) response = request.send().response assert_proper_response(response) response = response.json() expected_response = { 'channel_identifier': second_channel_identifier, 'partner_address': second_partner_address, 'token_address': to_checksum_address(token_address), 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance, } assert response == expected_response
def test_api_channel_state_change_errors( api_backend, api_test_context, api_raiden_service): # let's create a new channel partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 reveal_timeout = 30 channel_data_obj = { 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'reveal_timeout': reveal_timeout, } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response assert_proper_response(response, HTTPStatus.CREATED) response = response.json() channel_address = response['channel_address'] # let's try to settle the channel (we are bad!) request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state=CHANNEL_STATE_SETTLED) ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to set a random state request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state='inlimbo') ) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # let's try to set both new state and balance request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state=CHANNEL_STATE_CLOSED, balance=200) ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # let's try to path with no arguments request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), ) response = request.send().response assert_response_with_error(response, HTTPStatus.BAD_REQUEST) # ok now let's close and settle for real request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state=CHANNEL_STATE_CLOSED) ) response = request.send().response assert_proper_response(response) request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state=CHANNEL_STATE_SETTLED) ) response = request.send().response assert_proper_response(response) # let's try to deposit to a settled channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(balance=500) ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT) # and now let's try to settle again request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=channel_address ), json=dict(state=CHANNEL_STATE_SETTLED) ) response = request.send().response assert_response_with_error(response, HTTPStatus.CONFLICT)
def test_api_channel_state_change_errors(api_test_server, api_test_context, api_raiden_service, reveal_timeout): # let's create a new channel partner_address = "0x61c808d82a3ac53231750dadc13c777b59310bd9" token_address = "0xea674fdde714fd979de3edf0f56aa9716b898ec8" settle_timeout = 1650 channel_data_obj = { "partner_address": partner_address, "token_address": token_address, "settle_timeout": settle_timeout } request = grequests.put('http://localhost:5001/api/1/channels', json=channel_data_obj) response = request.send().response assert response and response.status_code == httplib.OK response = decode_response(response) channel_address = response['channel_address'] # let's try to settle the channel (we are bad!) request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'settled'}) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT # let's try to set a random state request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'inlimbo'}) response = request.send().response assert response is not None and response.status_code == httplib.BAD_REQUEST # let's try to set both new state and balance request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={ 'state': 'closed', 'balance': 200 }) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT # let's try to path with no arguments request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), ) response = request.send().response assert response is not None and response.status_code == httplib.BAD_REQUEST # ok now let's close and settle for real request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'closed'}) response = request.send().response assert response and response.status_code == httplib.OK request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'settled'}) response = request.send().response assert response and response.status_code == httplib.OK # let's try to deposit to a settled channel request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'balance': 500}) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT # and now let's try to settle again request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'settled'}) response = request.send().response assert response is not None and response.status_code == httplib.CONFLICT
def test_api_open_and_deposit_channel(api_test_server, api_test_context, api_raiden_service, reveal_timeout): # let's create a new channel first_partner_address = "0x61c808d82a3ac53231750dadc13c777b59310bd9" token_address = "0xea674fdde714fd979de3edf0f56aa9716b898ec8" settle_timeout = 1650 channel_data_obj = { "partner_address": first_partner_address, "token_address": token_address, "settle_timeout": settle_timeout } request = grequests.put('http://localhost:5001/api/1/channels', json=channel_data_obj) response = request.send().response assert response and response.status_code == httplib.OK response = decode_response(response) expected_response = channel_data_obj expected_response['reveal_timeout'] = reveal_timeout expected_response['balance'] = 0 expected_response['state'] = 'open' # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response first_channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # now let's open a channel and make a deposit too second_partner_address = '0x29fa6cf0cce24582a9b20db94be4b6e017896038' balance = 100 channel_data_obj = { "partner_address": second_partner_address, "token_address": token_address, "settle_timeout": settle_timeout, "balance": balance } request = grequests.put('http://localhost:5001/api/1/channels', json=channel_data_obj) response = request.send().response assert response and response.status_code == httplib.OK response = decode_response(response) expected_response = channel_data_obj expected_response['reveal_timeout'] = reveal_timeout expected_response['balance'] = balance expected_response['state'] = 'open' # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response expected_response['channel_address'] = response['channel_address'] second_channel_address = response['channel_address'] assert response == expected_response # let's deposit on the first channel request = grequests.patch('http://localhost:5001/api/1/channels/{}'.format( first_channel_address), json={'balance': balance}) response = request.send().response assert response and response.status_code == httplib.OK response = decode_response(response) expected_response = { "channel_address": first_channel_address, "partner_address": first_partner_address, "token_address": token_address, "settle_timeout": settle_timeout, "reveal_timeout": reveal_timeout, "state": 'open', "balance": balance } assert response == expected_response # finall let's try querying for the second channel request = grequests.get('http://localhost:5001/api/1/channels/{}'.format( second_channel_address)) response = request.send().response assert response and response.status_code == httplib.OK response = decode_response(response) expected_response = { "channel_address": second_channel_address, "partner_address": second_partner_address, "token_address": token_address, "settle_timeout": settle_timeout, "reveal_timeout": reveal_timeout, "state": 'open', "balance": balance } assert response == expected_response
def test_api_open_close_and_settle_channel( api_test_server, api_test_context, api_raiden_service): # let's create a new channel partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 channel_data_obj = { 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout } request = grequests.put( 'http://localhost:5001/api/1/channels', json=channel_data_obj ) response = request.send().response balance = 0 assert_proper_response(response) response = decode_response(response) expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = 'open' # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # let's the close the channel request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'closed'} ) response = request.send().response assert_proper_response(response) response = decode_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'state': 'closed', 'balance': balance } assert response == expected_response # let's settle the channel request = grequests.patch( 'http://localhost:5001/api/1/channels/{}'.format(channel_address), json={'state': 'settled'} ) response = request.send().response assert_proper_response(response) response = decode_response(response) expected_response = { 'channel_address': channel_address, 'partner_address': partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'state': 'settled', 'balance': balance } assert response == expected_response
def test_api_open_and_deposit_channel( api_backend, api_test_context, api_raiden_service): # let's create a new channel first_partner_address = '0x61c808d82a3ac53231750dadc13c777b59310bd9' token_address = '0xea674fdde714fd979de3edf0f56aa9716b898ec8' settle_timeout = 1650 channel_data_obj = { 'partner_address': first_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response assert_proper_response(response) response = decode_response(response) expected_response = channel_data_obj expected_response['balance'] = 0 expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response first_channel_address = response['channel_address'] expected_response['channel_address'] = response['channel_address'] assert response == expected_response # now let's open a channel and make a deposit too second_partner_address = '0x29fa6cf0cce24582a9b20db94be4b6e017896038' balance = 100 channel_data_obj = { 'partner_address': second_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'balance': balance } request = grequests.put( api_url_for(api_backend, 'channelsresource'), json=channel_data_obj ) response = request.send().response assert_proper_response(response) response = decode_response(response) expected_response = channel_data_obj expected_response['balance'] = balance expected_response['state'] = CHANNEL_STATE_OPENED # can't know the channel address beforehand but make sure we get one assert 'channel_address' in response expected_response['channel_address'] = response['channel_address'] second_channel_address = response['channel_address'] assert response == expected_response # let's deposit on the first channel request = grequests.patch( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=first_channel_address ), json={'balance': balance} ) response = request.send().response assert_proper_response(response) response = decode_response(response) expected_response = { 'channel_address': first_channel_address, 'partner_address': first_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance } assert response == expected_response # finally let's try querying for the second channel request = grequests.get( api_url_for( api_backend, 'channelsresourcebychanneladdress', channel_address=second_channel_address ) ) response = request.send().response assert_proper_response(response) response = decode_response(response) expected_response = { 'channel_address': second_channel_address, 'partner_address': second_partner_address, 'token_address': token_address, 'settle_timeout': settle_timeout, 'state': CHANNEL_STATE_OPENED, 'balance': balance } assert response == expected_response
def test_api_channel_open_and_deposit_race( api_server_test_instance: APIServer, raiden_network, token_addresses, reveal_timeout, token_network_registry_address, retry_timeout, ): """Tests that a race for the same deposit from the API is handled properly The proxy's approve_and_set_total_deposit is raising a RaidenRecoverableError in case of races. That needs to be properly handled and not allowed to bubble out of the greenlet. Regression test for https://github.com/raiden-network/raiden/issues/4937 """ app0 = raiden_network[0] # let's create a new channel first_partner_address = "0x61C808D82A3Ac53231750daDc13c777b59310bD9" token_address = token_addresses[0] settle_timeout = 1650 channel_data_obj = { "partner_address": first_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) json_response = get_json_response(response) expected_response = channel_data_obj.copy() expected_response.update({ "balance": "0", "state": ChannelState.STATE_OPENED.value, "channel_identifier": "1", "total_deposit": "0", }) assert check_dict_nested_attrs(json_response, expected_response) # Prepare the deposit api call deposit_amount = TokenAmount(99) request = grequests.patch( api_url_for( api_server_test_instance, "channelsresourcebytokenandpartneraddress", token_address=token_address, partner_address=first_partner_address, ), json={"total_deposit": str(deposit_amount)}, ) # Spawn two greenlets doing the same deposit request greenlets = [gevent.spawn(request.send), gevent.spawn(request.send)] gevent.joinall(set(greenlets), raise_error=True) # Make sure that both responses are fine g1_response = greenlets[0].get().response assert_proper_response(g1_response, HTTPStatus.OK) json_response = get_json_response(g1_response) expected_response.update({ "total_deposit": str(deposit_amount), "balance": str(deposit_amount) }) assert check_dict_nested_attrs(json_response, expected_response) g2_response = greenlets[0].get().response assert_proper_response(g2_response, HTTPStatus.OK) json_response = get_json_response(g2_response) assert check_dict_nested_attrs(json_response, expected_response) # Wait for the deposit to be seen timeout_seconds = 20 exception = Exception( f"Expected deposit not seen within {timeout_seconds}") with gevent.Timeout(seconds=timeout_seconds, exception=exception): wait_for_participant_deposit( raiden=app0.raiden, token_network_registry_address=token_network_registry_address, token_address=token_address, partner_address=to_canonical_address(first_partner_address), target_address=app0.raiden.address, target_balance=deposit_amount, retry_timeout=retry_timeout, ) 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["token_address"] == to_checksum_address(token_address) assert channel_info["total_deposit"] == str(deposit_amount)