def test_default_http_client_topup(doggo_proxy, default_http_client: DefaultHTTPClient, receiver_privkey): # Create a channel that has just enough capacity for one transfer. default_http_client.initial_deposit = lambda x: 0 check_response(default_http_client.run('doggo.jpg')) client = default_http_client.client open_channels = client.get_open_channels() assert len(open_channels) == 1 channel1 = open_channels[0] assert channel1 == default_http_client.channel assert channel1.balance_sig assert channel1.balance == channel1.deposit # Do another payment. Topup should occur. check_response(default_http_client.run('doggo.jpg')) open_channels = client.get_open_channels() assert len(open_channels) == 1 channel2 = open_channels[0] assert channel2 == default_http_client.channel assert channel2.balance_sig assert channel2.balance < channel2.deposit assert channel1 == channel2 close_channel_cooperatively(channel1, receiver_privkey, client.channel_manager_address)
def test_close_unconfirmed_event(channel_manager, client, receiver_address, wait_for_blocks): channel_manager.wait_sync() blockchain = channel_manager.blockchain # if unconfirmed channel is closed it should simply be forgotten channel = client.open_channel(receiver_address, 10) wait_for_blocks(1) gevent.sleep(blockchain.poll_interval) assert (channel.sender, channel.block) in channel_manager.unconfirmed_channels assert (channel.sender, channel.block) not in channel_manager.channels channel.close() wait_for_blocks( channel_manager.blockchain.n_confirmations) # opening confirmed gevent.sleep(blockchain.poll_interval) assert (channel.sender, channel.block) not in channel_manager.unconfirmed_channels assert (channel.sender, channel.block) in channel_manager.channels wait_for_blocks(1) # closing confirmed gevent.sleep(blockchain.poll_interval) assert (channel.sender, channel.block) not in channel_manager.unconfirmed_channels assert (channel.sender, channel.block) in channel_manager.channels close_channel_cooperatively( channel, channel_manager.private_key, channel_manager.contract_proxy.contract.address)
def test_sync(client: Client, receiver_address, receiver_privkey): c = client.get_suitable_channel(receiver_address, 5, initial_deposit=lambda x: x) assert c in client.channels assert c.deposit == 5 assert len(client.channels) == 1 # Check if channel is still valid after sync. client.sync_channels() assert c in client.channels assert len(client.channels) == 1 # Check if client handles topup events on sync. c_topup = client.get_suitable_channel(receiver_address, 7, topup_deposit=lambda x: 2) assert c_topup == c assert len(client.channels) == 1 assert c.deposit == 7 # Check if channel can be resynced after data loss. client.channels = [] client.sync_channels() assert len(client.channels) == 1 c = client.channels[0] assert c.deposit == 7 # Check if channel is forgotten on resync after closure. close_channel_cooperatively(c, receiver_privkey, client.context.channel_manager.address) client.sync_channels() assert c not in client.channels
def test_dynamic_price(empty_proxy: PaywalledProxy, api_endpoint_address: str, client: Client, wait_for_blocks, receiver_privkey: str): proxy = empty_proxy endpoint_url = "http://" + api_endpoint_address price_cycle = cycle([1, 2, 3, 4, 5]) url_to_price = {} def price_fn(url: str): if url in url_to_price: price = url_to_price[url] else: price = next(price_cycle) url_to_price[url] = price return price content = PaywalledContent( 'resource_\d', price=price_fn, get_fn=lambda url: (url.split("_")[1], 200), ) proxy.add_content(content) response = requests.get(endpoint_url + '/resource_3') assert response.status_code == 402 headers = HTTPHeaders.deserialize(response.headers) assert int(headers.price) == 1 response = requests.get(endpoint_url + '/resource_5') assert response.status_code == 402 headers = HTTPHeaders.deserialize(response.headers) assert int(headers.price) == 2 response = requests.get(endpoint_url + '/resource_2') assert response.status_code == 402 headers = HTTPHeaders.deserialize(response.headers) assert int(headers.price) == 3 response = requests.get(endpoint_url + '/resource_3') assert response.status_code == 402 headers = HTTPHeaders.deserialize(response.headers) assert int(headers.price) == 1 channel = client.get_suitable_channel(headers.receiver_address, 2) wait_for_blocks(6) channel.balance = 2 headers = Munch() headers.balance = str(channel.balance) headers.balance_signature = encode_hex(channel.balance_sig) headers.sender_address = channel.sender headers.open_block = str(channel.block) headers = HTTPHeaders.serialize(headers) response = requests.get(endpoint_url + '/resource_5', headers=headers) assert response.status_code == 200 assert response.text.strip() == '"5"' close_channel_cooperatively(channel, receiver_privkey, client.channel_manager_address, 0)
def test_static_price(empty_proxy: PaywalledProxy, api_endpoint_address: str, client: Client, wait_for_blocks, receiver_privkey: str): proxy = empty_proxy endpoint_url = "http://" + api_endpoint_address content = PaywalledContent( 'resource', price=3, get_fn=lambda url: ('SUCCESS', 200), ) proxy.add_content(content) response = requests.get(endpoint_url + '/resource') assert response.status_code == 402 headers = HTTPHeaders.deserialize(response.headers) assert int(headers.price) == 3 channel = client.get_suitable_channel(headers.receiver_address, 3) wait_for_blocks(6) channel.balance = 3 headers = Munch() headers.balance = str(channel.balance) headers.balance_signature = encode_hex(channel.balance_sig) headers.sender_address = channel.sender headers.open_block = str(channel.block) headers = HTTPHeaders.serialize(headers) response = requests.get(endpoint_url + '/resource', headers=headers) assert response.status_code == 200 assert response.text.strip() == '"SUCCESS"' close_channel_cooperatively(channel, receiver_privkey, client.channel_manager_address, 0)
def test_sync(client: Client, receiver_address, receiver_privkey): c = client.get_suitable_channel(receiver_address, 5, initial_deposit=lambda x: x) assert c is not None assert c in client.channels assert c.deposit == 5 assert len(client.channels) == 1 # Check if channel is still valid after sync. client.sync_channels() assert c in client.channels assert len(client.channels) == 1 # Check if client handles topup events on sync. c_topup = client.get_suitable_channel(receiver_address, 7, topup_deposit=lambda x: 2) assert c is not None assert c_topup == c assert len(client.channels) == 1 assert c.deposit == 7 # Check if channel can be resynced after data loss. client.channels = [] client.sync_channels() assert len(client.channels) == 1 c = client.channels[0] assert c.deposit == 7 # Check if channel is forgotten on resync after closure. close_channel_cooperatively(c, receiver_privkey, client.context.channel_manager.address) client.sync_channels() assert c not in client.channels
def confirmed_open_channel(channel_manager, client, receiver_address, receiver_privkey, wait_for_blocks): channel = client.open_channel(receiver_address, 10) wait_for_blocks(channel_manager.n_confirmations + 1) gevent.sleep(channel_manager.blockchain.poll_interval) assert (channel.sender, channel.block) in channel_manager.channels yield channel if not channel.state == channel.State.closed: close_channel_cooperatively(channel, receiver_privkey)
def test_default_http_client_existing_channel( doggo_proxy, default_http_client: DefaultHTTPClient, receiver_privkey, receiver_address): client = default_http_client.client channel = client.open_channel(receiver_address, 50) check_response(default_http_client.run('doggo.jpg')) assert channel.balance == 2 assert channel.deposit == 50 close_channel_cooperatively(channel, receiver_privkey, client.channel_manager_address)
def test_default_http_client_existing_channel_topup( doggo_proxy, default_http_client: DefaultHTTPClient, receiver_privkey, receiver_address): logging.basicConfig(level=logging.INFO) client = default_http_client.client default_http_client.topup_deposit = lambda x: 13 channel = client.open_channel(receiver_address, 1) check_response(default_http_client.run('doggo.jpg')) assert channel.balance == 2 assert channel.deposit == 13 close_channel_cooperatively(channel, receiver_privkey)
def test_unconfirmed_topup(channel_manager, client, receiver_address, wait_for_blocks): blockchain = channel_manager.blockchain channel_manager.wait_sync() channel = client.open_channel(receiver_address, 10) wait_for_blocks(1) gevent.sleep(blockchain.poll_interval) assert (channel.sender, channel.block) in channel_manager.unconfirmed_channels channel.topup(5) wait_for_blocks(channel_manager.blockchain.n_confirmations) gevent.sleep(blockchain.poll_interval) assert (channel.sender, channel.block) in channel_manager.channels channel_rec = channel_manager.channels[channel.sender, channel.block] assert channel_rec.deposit == 15 close_channel_cooperatively(channel, channel_manager.private_key)
def test_client(client: Client, receiver_privkey, receiver_address): """test if contract calls go through""" c = client.open_channel(receiver_address, 10) assert c is not None sig = c.create_transfer(5) assert sig is not None ev = c.topup(10) assert ev is not None assert c.deposit == 20 ev = c.close() assert ev is not None close_channel_cooperatively(c, receiver_privkey, client.channel_manager_address)
def test_default_http_client(doggo_proxy, default_http_client: DefaultHTTPClient, sender_address, receiver_privkey, receiver_address): check_response(default_http_client.run('doggo.jpg')) client = default_http_client.client open_channels = client.get_open_channels() assert len(open_channels) == 1 channel = open_channels[0] assert channel == default_http_client.channel assert channel.balance_sig assert channel.balance < channel.deposit assert channel.sender == sender_address assert channel.receiver == receiver_address close_channel_cooperatively(channel, receiver_privkey, client.channel_manager_address)
def test_client(client: Client, receiver_privkey, receiver_address): """test if contract calls go through""" import logging logging.basicConfig(level=logging.INFO) c = client.open_channel(receiver_address, 10) assert c is not None sig = c.create_transfer(5) assert sig is not None ev = c.topup(10) assert ev is not None assert c.deposit == 20 ev = c.close() assert ev is not None close_channel_cooperatively(c, receiver_privkey)
def test_sync(client: Client, receiver_address, receiver_privkey): c = client.get_suitable_channel(receiver_address, 5) assert c in client.channels assert len(client.channels) == 1 # Check if channel is still valid after sync. client.sync_channels() assert c in client.channels assert len(client.channels) == 1 # Check if channel can be resynced after data loss. client.channels = [] client.store_channels() client.sync_channels() # Check if channel is forgotten on resync after closure. assert len(client.channels) == 1 c = client.channels[0] close_channel_cooperatively(c, receiver_privkey) client.sync_channels() assert c not in client.channels
def test_coop_close(doggo_proxy, default_http_client: DefaultHTTPClient, sender_address, receiver_privkey, receiver_address): check_response(default_http_client.run('doggo.jpg')) client = default_http_client.client open_channels = client.get_open_channels() assert len(open_channels) == 1 channel = open_channels[0] import requests reply = requests.get('http://localhost:5000/api/1/channels/%s/%s' % (channel.sender, channel.block)) assert reply.status_code == 200 json_reply = json.loads(reply.text) request_data = {'balance': json_reply['balance']} reply = requests.delete('http://localhost:5000/api/1/channels/%s/%s' % (channel.sender, channel.block), data=request_data) assert reply.status_code == 200 close_channel_cooperatively(channel, receiver_privkey, client.channel_manager_address)