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