tests: Add script test

tests/basicswap/extended/test_scripts.py

@@ -0,0 +1,654 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2023 tecnovert
+# Distributed under the MIT software license, see the accompanying
+# file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+
+"""
+Start test_xmr_persistent.py
+
+python tests/basicswap/extended/test_scripts.py
+
+pytest -v -s tests/basicswap/extended/test_scripts.py::Test::test_bid_tracking
+
+"""
+
+import os
+import sys
+import json
+import time
+import math
+import logging
+import sqlite3
+import unittest
+import threading
+import subprocess
+import http.client
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib import parse
+
+from tests.basicswap.util import (
+    read_json_api,
+    waitForServer,
+)
+
+
+logger = logging.getLogger()
+logger.level = logging.DEBUG
+if not len(logger.handlers):
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+
+PORT_OFS = int(os.getenv('PORT_OFS', 1))
+UI_PORT = 12700 + PORT_OFS
+
+
+class HttpHandler(BaseHTTPRequestHandler):
+
+    def js_response(self, url_split, post_string, is_json):
+        return bytes(json.dumps(self.server.return_data[url_split[3]]), 'UTF-8')
+
+    def putHeaders(self, status_code, content_type):
+        self.send_response(status_code)
+        self.send_header('Content-Type', content_type)
+        self.end_headers()
+
+    def handle_http(self, status_code, path, post_string='', is_json=False):
+        parsed = parse.urlparse(self.path)
+        url_split = parsed.path.split('/')
+        if post_string == '' and len(parsed.query) > 0:
+            post_string = parsed.query
+        if len(url_split) > 1 and url_split[1] == 'json':
+            self.putHeaders(status_code, 'text/plain')
+            return self.js_response(url_split, post_string, is_json)
+
+        self.putHeaders(status_code, 'text/plain')
+        return bytes('No response', 'UTF-8')
+
+    def do_GET(self):
+        response = self.handle_http(200, self.path)
+        self.wfile.write(response)
+
+    def do_POST(self):
+        post_string = self.rfile.read(int(self.headers.get('Content-Length')))
+
+        is_json = True if 'json' in self.headers.get('Content-Type', '') else False
+        response = self.handle_http(200, self.path, post_string, is_json)
+        self.wfile.write(response)
+
+    def do_HEAD(self):
+        self.putHeaders(200, 'text/html')
+
+
+class HttpThread(threading.Thread, HTTPServer):
+    host = '127.0.0.1'
+    port_no = 12699
+    stop_event = threading.Event()
+    return_data = {'test': 1}
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+
+        HTTPServer.__init__(self, (self.host, self.port_no), HttpHandler)
+
+    def stop(self):
+        self.stop_event.set()
+
+        # Send fake request
+        conn = http.client.HTTPConnection(self.host, self.port_no)
+        conn.connect()
+        conn.request('GET', '/none')
+        response = conn.getresponse()
+        data = response.read()
+        conn.close()
+
+    def serve_forever(self):
+        while not self.stop_event.is_set():
+            self.handle_request()
+        self.socket.close()
+
+    def run(self):
+        self.serve_forever()
+
+
+def clear_offers(delay_event, node_id) -> None:
+    logging.info(f'clear_offers node {node_id}')
+    offers = read_json_api(UI_PORT + node_id, 'offers')
+
+    for offer in offers:
+        read_json_api(UI_PORT + node_id, 'revokeoffer/{}'.format(offer['offer_id']))
+
+    for i in range(20):
+        delay_event.wait(1)
+        offers = read_json_api(UI_PORT + node_id, 'offers')
+        if len(offers) == 0:
+            return
+    raise ValueError('clear_offers failed')
+
+
+def wait_for_offers(delay_event, node_id, num_offers) -> None:
+    logging.info(f'Waiting for {num_offers} offers on node {node_id}')
+    for i in range(20):
+        delay_event.wait(1)
+        offers = read_json_api(UI_PORT + node_id, 'offers')
+        if len(offers) >= num_offers:
+            return
+    raise ValueError('wait_for_offers failed')
+
+
+def delete_file(filepath: str) -> None:
+    if os.path.exists(filepath):
+        os.remove(filepath)
+
+
+def get_created_offers(rv_stdout):
+    offers = []
+    for line in rv_stdout:
+        if line.startswith('New offer'):
+            offers.append(line.split(':')[1].strip())
+    return offers
+
+
+def count_lines_with(rv_stdout, str_needle):
+    lines_found = 0
+    for line in rv_stdout:
+        if str_needle in line:
+            lines_found += 1
+    return lines_found
+
+
+def get_created_bids(rv_stdout):
+    bids = []
+    for line in rv_stdout:
+        if line.startswith('New bid'):
+            bids.append(line.split(':')[1].strip())
+    return bids
+
+
+def get_possible_bids(rv_stdout):
+    bids = []
+    tag = 'Would create bid: '
+    for line in rv_stdout:
+        if line.startswith(tag):
+            bids.append(json.loads(line[len(tag):].replace("'", '"')))
+    return bids
+
+
+class Test(unittest.TestCase):
+    delay_event = threading.Event()
+    thread_http = HttpThread()
+
+    @classmethod
+    def setUpClass(cls):
+        super(Test, cls).setUpClass()
+        cls.thread_http.start()
+
+        script_path = 'scripts/createoffers.py'
+        datadir = '/tmp/bsx_scripts'
+        if not os.path.isdir(datadir):
+            os.makedirs(datadir)
+
+        cls.node0_configfile = os.path.join(datadir, 'node0.json')
+        cls.node0_statefile = os.path.join(datadir, 'node0_state.json')
+        cls.node0_args = [script_path, '--port', str(UI_PORT), '--configfile', cls.node0_configfile, '--statefile', cls.node0_statefile, '--oneshot', '--debug']
+
+        cls.node1_configfile = os.path.join(datadir, 'node1.json')
+        cls.node1_statefile = os.path.join(datadir, 'node1_state.json')
+        cls.node1_args = [script_path, '--port', str(UI_PORT + 1), '--configfile', cls.node1_configfile, '--statefile', cls.node1_statefile, '--oneshot', '--debug']
+
+
+    @classmethod
+    def tearDownClass(cls):
+        logging.info('Stopping test')
+        cls.thread_http.stop()
+
+    def test_offers(self):
+
+        waitForServer(self.delay_event, UI_PORT + 0)
+        waitForServer(self.delay_event, UI_PORT + 1)
+
+        # Reset test
+        clear_offers(self.delay_event, 0)
+        delete_file(self.node0_statefile)
+        delete_file(self.node1_statefile)
+        wait_for_offers(self.delay_event, 1, 0)
+
+        node0_test1_config = {
+            'offers': [
+                {
+                    'name': 'offer example 1',
+                    'coin_from': 'Particl',
+                    'coin_to': 'Monero',
+                    'amount': 20,
+                    'minrate': 0.05,
+                    'ratetweakpercent': 5,
+                    'amount_variable': True,
+                    'address': -1,
+                    'min_coin_from_amt': 20,
+                    'max_coin_to_amt': -1
+                },
+                {
+                    'name': 'offer example 1_2',
+                    'coin_from': 'Particl',
+                    'coin_to': 'Monero',
+                    'amount': 21,
+                    'minrate': 0.07,
+                    'ratetweakpercent': 5,
+                    'amount_variable': True,
+                    'address': -1,
+                    'min_coin_from_amt': 21,
+                    'max_coin_to_amt': -1
+                }
+            ],
+        }
+        with open(self.node0_configfile, 'w') as fp:
+            json.dump(node0_test1_config, fp, indent=4)
+
+        logging.info('Test that an offer is created')
+        result = subprocess.run(self.node0_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_created_offers(rv_stdout)) == 1)
+
+        offers = read_json_api(UI_PORT, 'offers')
+        assert (len(offers) == 1)
+
+        logging.info('Test that an offer is not created while delaying')
+        result = subprocess.run(self.node0_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_created_offers(rv_stdout)) == 0)
+
+        with open(self.node0_statefile) as fs:
+            node0_state = json.load(fs)
+        node0_state['delay_next_offer_before'] = 0
+        with open(self.node0_statefile, 'w') as fp:
+            json.dump(node0_state, fp, indent=4)
+
+        logging.info('Test that the second offer is created when not delaying')
+        result = subprocess.run(self.node0_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_created_offers(rv_stdout)) == 1)
+
+        with open(self.node0_statefile) as fs:
+            node0_state = json.load(fs)
+        assert (len(node0_state['offers']['offer example 1']) == 1)
+        assert (len(node0_state['offers']['offer example 1_2']) == 1)
+
+        offers = read_json_api(UI_PORT, 'offers')
+        assert (len(offers) == 2)
+
+        addr_bid_from = read_json_api(UI_PORT + 1, 'smsgaddresses/new')['new_address']
+        node1_test1_config = {
+            'bids': [
+                {
+                    'name': 'bid example 1',
+                    'coin_from': 'PART',
+                    'coin_to': 'XMR',
+                    'amount': 10,
+                    'maxrate': 0.06,
+                    'amount_variable': True,
+                    'address': addr_bid_from,
+                    'min_swap_amount': 0.1,
+                    'max_coin_from_balance': -1,
+                    'min_coin_to_balance': -1,
+                    'max_concurrent': 4,
+                },
+                {
+                    'coin_from': 'PART',
+                    'coin_to': 'XMR',
+                    'amount': 10,
+                    'maxrate': 0.04,
+                    'amount_variable': True,
+                    'address': -1,
+                    'min_swap_amount': 0.1,
+                    'max_coin_from_balance': -1,
+                    'min_coin_to_balance': -1,
+                }
+            ],
+        }
+        with open(self.node1_configfile, 'w') as fp:
+            json.dump(node1_test1_config, fp, indent=4)
+
+        wait_for_offers(self.delay_event, 1, 2)
+
+        logging.info('Test that a bid is created')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_created_bids(rv_stdout)) == 1)
+
+        logging.info('Test no bids are created while delaying')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (count_lines_with(rv_stdout, 'Delaying bids until') == 1)
+
+        with open(self.node1_statefile) as fs:
+            node1_state = json.load(fs)
+        node1_state['delay_next_bid_before'] = 0
+        with open(self.node1_statefile, 'w') as fp:
+            json.dump(node1_state, fp, indent=4)
+
+        logging.info('Test that a bid is not created if one already exists on that offer')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (count_lines_with(rv_stdout, 'Bid rate too low for offer') == 3)
+        assert (count_lines_with(rv_stdout, 'Already bidding on offer') == 1)
+
+        logging.info(f'Modifying node1 config')
+        node1_test1_config['bids'][0]['maxrate'] = 0.07
+        node1_test1_config['bids'][0]['max_coin_from_balance'] = 100
+        node1_test1_config['bids'][0]['min_coin_to_balance'] = 100
+        node1_test1_config['bids'][0]['min_swap_amount'] = 9
+        node1_test1_config['wallet_port_override'] = 12699
+        node1_test1_config['test_mode'] = True
+        with open(self.node1_configfile, 'w') as fp:
+            json.dump(node1_test1_config, fp, indent=4)
+
+        self.thread_http.return_data = {
+            'PART': {
+                'balance': '0.0',
+                'unconfirmed': '0.0',
+                'expected_seed': True,
+                'encrypted': False,
+                'locked': False,
+                'anon_balance': 0.0,
+                'anon_pending': 0.0,
+                'blind_balance': 0.0,
+                'blind_unconfirmed': 0.0,
+                'version': 23000300,
+                'name': 'Particl',
+                'blocks': 3556,
+                'synced': '100.00'
+            },
+            'XMR': {
+                'balance': '362299.12',
+                'unconfirmed': '0.0',
+                'expected_seed': True,
+                'encrypted': False,
+                'locked': False,
+                'main_address': '',
+                'version': 65562,
+                'name': 'Monero',
+                'blocks': 10470,
+                'synced': '100.00',
+                'known_block_count': 10470
+            }
+        }
+
+        # Check max_coin_from_balance (bids increase coin_from)
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        possible_bids = get_possible_bids(rv_stdout)
+        assert (len(possible_bids) == 1)
+        assert (float(possible_bids[0]['amount_from']) == 21.0)
+
+        # Test multiple bids are delayed
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (count_lines_with(rv_stdout, 'Delaying bids until') == 1)
+
+        delete_file(self.node1_statefile)
+        self.thread_http.return_data['PART']['balance'] = 100.0
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (count_lines_with(rv_stdout, 'Bid amount would exceed maximum wallet total') == 1)
+
+        self.thread_http.return_data['PART']['balance'] = 90.0
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        possible_bids = get_possible_bids(rv_stdout)
+        assert (len(possible_bids) == 1)
+        assert (math.isclose(float(possible_bids[0]['amount_from']), 10.0))
+
+        # Check min_swap_amount
+        delete_file(self.node1_statefile)
+        self.thread_http.return_data['PART']['balance'] = 95.0
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        possible_bids = get_possible_bids(rv_stdout)
+        assert (count_lines_with(rv_stdout, 'Bid amount would exceed maximum wallet total') == 1)
+
+        # Check min_coin_to_balance (bids decrease coin_to)
+        self.thread_http.return_data['PART']['balance'] = 0.0
+        self.thread_http.return_data['XMR']['balance'] = 101.0
+
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        possible_bids = get_possible_bids(rv_stdout)
+        possible_bids = get_possible_bids(rv_stdout)
+        assert (len(possible_bids) == 1)
+        assert (float(possible_bids[0]['amount_from'] < 20.0))
+
+        logging.info(f'Adding mock data to node1 db for tests')
+        rows = []
+        offers = read_json_api(UI_PORT, 'offers')
+
+        now = int(time.time())
+        for offer in offers:
+            rows.append((1, offer['addr_from'], 5, 5, now, now))
+        db_path = '/tmp/test_persistent/client1/db_regtest.sqlite'
+        with sqlite3.connect(db_path) as dbc:
+            c = dbc.cursor()
+            c.executemany('INSERT INTO knownidentities (active_ind, address, num_sent_bids_failed, num_recv_bids_failed, updated_at, created_at) VALUES (?,?,?,?,?,?)', rows)
+            dbc.commit()
+
+        delete_file(self.node1_statefile)
+        self.thread_http.return_data['XMR']['balance'] = 10000.0
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_possible_bids(get_possible_bids(rv_stdout))) == 0)
+        assert (count_lines_with(rv_stdout, 'too many failed bids') == 1)
+
+        '''
+        TODO
+        node0_test1_config['stealthex'] = [
+            {
+                'coin_from': 'XMR',
+                'coin_to': 'BTC',
+                'min_balance_from': 1,
+                'min_amount_tx': 1,
+                'max_amount_tx': 5,
+                'min_rate': 0.01,
+                'refund_address': 'auto',
+                'receive_address': 'auto',
+                'api_key': 'API_KEY_HERE'
+            }
+        ]
+        node0_test1_config['wallet_port_override'] = 12699
+        node0_test1_config['test_mode'] = True
+        with open(self.node0_configfile, 'w') as fp:
+            json.dump(node0_test1_config, fp, indent=4)
+
+        result = subprocess.run(self.node0_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        '''
+
+    def test_bid_tracking(self):
+
+        waitForServer(self.delay_event, UI_PORT + 0)
+        waitForServer(self.delay_event, UI_PORT + 1)
+
+        # Reset test
+        clear_offers(self.delay_event, 0)
+        delete_file(self.node0_statefile)
+        delete_file(self.node1_statefile)
+        wait_for_offers(self.delay_event, 1, 0)
+
+        addrs = []
+        for i in range(2):
+            addrs.append(read_json_api(UI_PORT, 'smsgaddresses/new')['new_address'])
+
+        node0_test2_config = {
+            'offers': [
+                {
+                    'name': 'offer example 1',
+                    'coin_from': 'Particl',
+                    'coin_to': 'Monero',
+                    'amount': 20,
+                    'minrate': 0.04,
+                    'ratetweakpercent': 5,
+                    'amount_variable': True,
+                    'address': addrs[0],
+                    'min_coin_from_amt': 20,
+                    'max_coin_to_amt': -1
+                },
+                {
+                    'name': 'offer example 1_2',
+                    'coin_from': 'Particl',
+                    'coin_to': 'Monero',
+                    'amount': 21,
+                    'minrate': 0.05,
+                    'ratetweakpercent': 5,
+                    'amount_variable': True,
+                    'address': addrs[1],
+                    'min_coin_from_amt': 21,
+                    'max_coin_to_amt': -1
+                },
+                {
+                    'name': 'offer example 1_3',
+                    'coin_from': 'Particl',
+                    'coin_to': 'Monero',
+                    'amount': 22,
+                    'minrate': 0.06,
+                    'ratetweakpercent': 5,
+                    'amount_variable': True,
+                    'address': 'auto',
+                    'min_coin_from_amt': 22,
+                    'max_coin_to_amt': -1
+                }
+            ],
+        }
+        with open(self.node0_configfile, 'w') as fp:
+            json.dump(node0_test2_config, fp, indent=4)
+
+        offer_ids = []
+        logging.info('Create three offers')
+
+
+        for i in range(3):
+            if i > 0:
+                with open(self.node0_statefile) as fs:
+                    node0_state = json.load(fs)
+                node0_state['delay_next_offer_before'] = 0
+                with open(self.node0_statefile, 'w') as fp:
+                    json.dump(node0_state, fp, indent=4)
+
+            result = subprocess.run(self.node0_args, stdout=subprocess.PIPE)
+            rv_stdout = result.stdout.decode().split('\n')
+            created_offers = get_created_offers(rv_stdout)
+            assert (len(get_created_offers(rv_stdout)) == 1)
+            offer_ids.append(created_offers[0])
+
+        found_addrs = {}
+        for offer_id in offer_ids:
+            offer = read_json_api(UI_PORT, f'offers/{offer_id}')[0]
+            found_addrs[offer['addr_from']] = found_addrs.get(offer['addr_from'], 0) + 1
+
+        for addr in addrs:
+            assert (found_addrs[addr] == 1)
+
+        addr_bid_from = read_json_api(UI_PORT + 1, 'smsgaddresses/new')['new_address']
+        node1_test1_config = {
+            'bids': [
+                {
+                    'name': 'bid example 1',
+                    'coin_from': 'PART',
+                    'coin_to': 'XMR',
+                    'amount': 50,
+                    'maxrate': 0.08,
+                    'amount_variable': False,
+                    'address': addr_bid_from,
+                    'min_swap_amount': 1,
+                    'max_coin_from_balance': -1,
+                    'min_coin_to_balance': -1
+                }
+            ],
+        }
+        with open(self.node1_configfile, 'w') as fp:
+            json.dump(node1_test1_config, fp, indent=4)
+
+        wait_for_offers(self.delay_event, 1, 3)
+
+        logging.info('Check that no bids are created (offer values too low)')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_created_bids(rv_stdout)) == 0)
+        assert (count_lines_with(rv_stdout, 'Offer amount too low for bid') == 3)
+
+        node1_test1_config['bids'][0]['amount_variable'] = True
+        with open(self.node1_configfile, 'w') as fp:
+            json.dump(node1_test1_config, fp, indent=4)
+
+        logging.info('Check that one bid is created at the best rate')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        created_bids = get_created_bids(rv_stdout)
+        assert (len(created_bids) == 1)
+
+        bid_id = created_bids[0].split(' ')[0]
+        bid = read_json_api(UI_PORT + 1, f'bids/{bid_id}')
+        assert (math.isclose(float(bid['bid_rate']), 0.04))
+        assert (math.isclose(float(bid['amt_from']), 20.0))
+        assert (bid['addr_from'] == addr_bid_from)
+
+        logging.info('Check that bids are delayed')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (count_lines_with(rv_stdout, 'Delaying bids until') == 1)
+        assert (len(get_created_bids(rv_stdout)) == 0)
+
+        with open(self.node1_statefile) as fs:
+            node1_state = json.load(fs)
+        node1_state['delay_next_bid_before'] = 0
+        with open(self.node1_statefile, 'w') as fp:
+            json.dump(node1_state, fp, indent=4)
+
+        logging.info('Test that a bid is not created while one is active')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        assert (len(get_created_bids(rv_stdout)) == 0)
+        assert (count_lines_with(rv_stdout, 'Max concurrent bids') == 1)
+
+        logging.info('Waiting for bid to complete')
+        bid_complete: bool = False
+        for i in range(60):
+            self.delay_event.wait(5)
+            bid = read_json_api(UI_PORT + 1, f'bids/{bid_id}')
+            print('bid_state', bid['bid_state'])
+            if bid['bid_state'] == 'Completed':
+                bid_complete = True
+                break
+
+        assert bid_complete
+
+        logging.info('Test that a bid is created after one expires')
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        created_bids = get_created_bids(rv_stdout)
+        assert (len(created_bids) == 1)
+        assert (count_lines_with(rv_stdout, 'Marking bid inactive') == 1)
+
+        logging.info('Test that two bids are created if max concurrent is raised')
+        node1_test1_config['bids'][0]['max_concurrent'] = 2
+        with open(self.node1_configfile, 'w') as fp:
+            json.dump(node1_test1_config, fp, indent=4)
+
+        with open(self.node1_statefile) as fs:
+            node1_state = json.load(fs)
+        node1_state['delay_next_bid_before'] = 0
+        with open(self.node1_statefile, 'w') as fp:
+            json.dump(node1_state, fp, indent=4)
+
+        result = subprocess.run(self.node1_args, stdout=subprocess.PIPE)
+        rv_stdout = result.stdout.decode().split('\n')
+        created_bids = get_created_bids(rv_stdout)
+        assert (len(created_bids) == 1)
+
+        bid_id = created_bids[0].split(' ')[0]
+        bid = read_json_api(UI_PORT + 1, f'bids/{bid_id}')
+        assert (math.isclose(float(bid['bid_rate']), 0.05))
+        assert (math.isclose(float(bid['amt_from']), 21.0))
+        assert (bid['addr_from'] == addr_bid_from)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/basicswap/test_btc_xmr.py

@@ -254,6 +254,12 @@ class BasicSwapTest(BaseTest):
         self.callnoderpc('unloadwallet', [new_wallet_name])
         assert (addr == 'bcrt1qps7hnjd866e9ynxadgseprkc2l56m00dvwargr')
 
+        self.swap_clients[0].initialiseWallet(Coins.BTC, raise_errors=True)
+        assert self.swap_clients[0].checkWalletSeed(Coins.BTC) is True
+        for i in range(1500):
+            self.callnoderpc('getnewaddress')
+        assert self.swap_clients[0].checkWalletSeed(Coins.BTC) is True
+
     def do_test_01_full_swap(self, coin_from, coin_to):
         logging.info('---------- Test {} to {}'.format(coin_from.name, coin_to.name))
 

tests/basicswap/test_run.py

@@ -133,6 +133,18 @@ class Test(BaseTest):
         rv = read_json_api(1800, 'getcoinseed', {'coin': 'BTC'})
         assert (rv['seed'] == '8e54a313e6df8918df6d758fafdbf127a115175fdd2238d0e908dd8093c9ac3b')
 
+        rv = read_json_api(1800, 'identities/ppCsRro5po7Yu6kyu5XjSyr3A1PPdk9j1F', {'set_label': 'test 1'})
+        assert (len(rv) == 1)
+        assert (rv[0]['address'] == 'ppCsRro5po7Yu6kyu5XjSyr3A1PPdk9j1F')
+        assert (rv[0]['label'] == 'test 1')
+        rv = read_json_api(1800, 'identities/ppCsRro5po7Yu6kyu5XjSyr3A1PPdk9j1F', {'set_label': 'test 2'})
+        assert (len(rv) == 1)
+        assert (rv[0]['address'] == 'ppCsRro5po7Yu6kyu5XjSyr3A1PPdk9j1F')
+        assert (rv[0]['label'] == 'test 2')
+
+        rv = read_json_api(1800, 'identities/pPCsRro5po7Yu6kyu5XjSyr3A1PPdk9j1F', {'set_label': 'test 3'})
+        assert (rv['error'] == 'Invalid identity address')
+
     def test_01_verifyrawtransaction(self):
         txn = '0200000001eb6e5c4ebba4efa32f40c7314cad456a64008e91ee30b2dd0235ab9bb67fbdbb01000000ee47304402200956933242dde94f6cf8f195a470f8d02aef21ec5c9b66c5d3871594bdb74c9d02201d7e1b440de8f4da672d689f9e37e98815fb63dbc1706353290887eb6e8f7235012103dc1b24feb32841bc2f4375da91fa97834e5983668c2a39a6b7eadb60e7033f9d205a803b28fe2f86c17db91fa99d7ed2598f79b5677ffe869de2e478c0d1c02cc7514c606382012088a8201fe90717abb84b481c2a59112414ae56ec8acc72273642ca26cc7a5812fdc8f68876a914225fbfa4cb725b75e511810ac4d6f74069bdded26703520140b27576a914207eb66b2fd6ed9924d6217efc7fa7b38dfabe666888acffffffff01e0167118020000001976a9140044e188928710cecba8311f1cf412135b98145c88ac00000000'
         prevout = {