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 run(key_path, key_password_path, resource): # create the client with Client(key_path=key_path, key_password_path=key_password_path) as client: m2mclient = DefaultHTTPClient( client, 'localhost', 5000 ) # Get the resource. If payment is required, client will attempt to create # a channel or will use existing one. status, headers, body = m2mclient.run(resource) if status == requests.codes.OK: if re.match('^text\/', headers['Content-Type']): logging.info("got the resource %s type=%s\n%s" % ( resource, headers.get('Content-Type', '???'), body)) else: logging.info("got the resource %s type=%s" % ( resource, headers.get('Content-Type', '???'))) else: logging.error("error getting the resource. code=%d body=%s" % (status, body.decode().strip()))
def test_resource_request(doggo_proxy, default_http_client: DefaultHTTPClient): requests = 1000 default_http_client.initial_deposit = lambda x: (requests + 1) * x # First transfer creates channel on-chain => exclude from profiling. response = default_http_client.run('doggo.jpg') assert response.decode().strip() == '"HI I AM A DOGGO"' t_start = time.time() for i in range(requests): log.debug('Transfer {}'.format(i)) response = default_http_client.run('doggo.jpg') assert response.decode().strip() == '"HI I AM A DOGGO"' t_diff = time.time() - t_start log.info("{} requests in {} ({} rps)".format( requests, datetime.timedelta(seconds=t_diff), requests / t_diff))
def test_default_http_client_close(doggo_proxy, default_http_client: DefaultHTTPClient): client = default_http_client.client check_response(default_http_client.run('doggo.jpg')) default_http_client.close_active_channel() open_channels = client.get_open_channels() assert len(open_channels) == 0
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_cheating_client(doggo_proxy, default_http_client: DefaultHTTPClient): """this test scenario where client sends less funds than what is requested by the server. In such case, a "RDN-Invalid-Amount=1" header should be sent in a server's reply """ # patch default http client to use price lower than the server suggests def patched_payment(self: DefaultHTTPClient, receiver: str, price: int, balance: int, balance_sig: bytes, channel_manager_address: str): self.invalid_amount_received = 0 return DefaultHTTPClient.on_payment_requested( self, receiver, price + self.price_adjust, balance, balance_sig, channel_manager_address) def patched_on_invalid_amount(self: DefaultHTTPClient): DefaultHTTPClient.on_invalid_amount(self) self.invalid_amount_received = 1 default_http_client.on_invalid_amount = types.MethodType( patched_on_invalid_amount, default_http_client) default_http_client.on_payment_requested = types.MethodType( patched_payment, default_http_client) # correct amount default_http_client.price_adjust = 0 response = default_http_client.run('doggo.jpg') check_response(response) assert default_http_client.invalid_amount_received == 0 # underpay default_http_client.price_adjust = -1 response = default_http_client.run('doggo.jpg') assert response is None assert default_http_client.invalid_amount_received == 1 # overpay default_http_client.price_adjust = 1 response = default_http_client.run('doggo.jpg') assert response is None assert default_http_client.invalid_amount_received == 1
def run(api_endpoint, api_port, **kwargs): exclude_kwargs = {'close_channels'} kwargs_client = { key: value for key, value in kwargs.items() if value and key not in exclude_kwargs } with Client(**kwargs_client) as client: m2mclient = DefaultHTTPClient(client, api_endpoint, api_port) resource = m2mclient.run('doggo.jpg') log.info('Response: {}'.format(resource)) if kwargs['close_channels'] is True: for channel in client.channels: if channel.state == Channel.State.open: channel.close_channel()
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_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)
class ETHTickerClient(ttk.Frame): def __init__( self, sender_privkey: str, httpclient: DefaultHTTPClient = None ): self.root = tkinter.Tk() ttk.Frame.__init__(self, self.root) self.root.title('µRaiden ETH Ticker') self.root.protocol('WM_DELETE_WINDOW', self.close) self.pack() self.pricevar = tkinter.StringVar(value='0.00 USD') ttk.Label(self, textvariable=self.pricevar, font=('Helvetica', '72')).pack() if httpclient: self.httpclient = httpclient self.client = httpclient.client else: self.client = Client(sender_privkey) self.httpclient = DefaultHTTPClient( self.client, 'localhost', 5000, initial_deposit=lambda x: 10 * x, topup_deposit=lambda x: 5 * x ) self.active_query = False self.running = False def run(self): self.running = True self.root.after(1000, self.query_price) self.root.mainloop() def query_price(self): if not self.running: return self.active_query = True response = self.httpclient.run('ETHUSD') if response: ticker = json.loads(response.decode()) price = float(ticker['last_price']) log.info('New price received: {:.2f} USD'.format(price)) self.pricevar.set('{:.2f} USD'.format(price)) else: log.warning('No response.') if self.running: self.root.after(5000, self.query_price) self.active_query = False def close(self): log.info('Shutting down gracefully.') self.running = False self.root.destroy() self.httpclient.stop() # Sloppy handling of thread joining but works for this small demo. while self.active_query: gevent.sleep(1) self.httpclient.close_active_channel() self.client.close()
def test_ssl_client(doggo_proxy, default_http_client: DefaultHTTPClient): default_http_client.use_ssl = True with disable_ssl_check(): check_response(default_http_client.run('doggo.jpg')) with pytest.raises(SSLError): check_response(default_http_client.run('doggo.jpg'))