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)
