Merge branch 'master' into chainmonitor

test/pisa/unit/conftest.py

@@ -12,11 +12,11 @@ from cryptography.hazmat.primitives import serialization
 
 from apps.cli.blob import Blob
 from pisa.responder import TransactionTracker
-from pisa.watcher import Watcher
 from pisa.tools import bitcoin_cli
 from pisa.db_manager import DBManager
 from pisa.chain_monitor import ChainMonitor
 from common.appointment import Appointment
+from common.tools import compute_locator
 
 from bitcoind_mock.utils import sha256d
 from bitcoind_mock.transaction import TX
@@ -115,7 +115,7 @@ def generate_dummy_appointment_data(real_height=True, start_time_offset=5, end_t
         encoding=serialization.Encoding.DER, format=serialization.PublicFormat.SubjectPublicKeyInfo
     )
 
-    locator = Watcher.compute_locator(dispute_txid)
+    locator = compute_locator(dispute_txid)
     blob = Blob(dummy_appointment_data.get("tx"))
 
     encrypted_blob = Cryptographer.encrypt(blob, dummy_appointment_data.get("tx_id"))
@@ -159,3 +159,26 @@ def generate_dummy_tracker():
     )
 
     return TransactionTracker.from_dict(tracker_data)
+
+
+def get_config():
+    config = {
+        "BTC_RPC_USER": "username",
+        "BTC_RPC_PASSWD": "password",
+        "BTC_RPC_HOST": "localhost",
+        "BTC_RPC_PORT": 8332,
+        "BTC_NETWORK": "regtest",
+        "FEED_PROTOCOL": "tcp",
+        "FEED_ADDR": "127.0.0.1",
+        "FEED_PORT": 28332,
+        "MAX_APPOINTMENTS": 100,
+        "EXPIRY_DELTA": 6,
+        "MIN_TO_SELF_DELAY": 20,
+        "SERVER_LOG_FILE": "pisa.log",
+        "PISA_SECRET_KEY": "pisa_sk.der",
+        "CLIENT_LOG_FILE": "pisa.log",
+        "TEST_LOG_FILE": "test.log",
+        "DB_PATH": "appointments",
+    }
+
+    return config

test/pisa/unit/test_api.py

@@ -9,7 +9,6 @@ from pisa.api import API
 from pisa.watcher import Watcher
 from pisa.tools import bitcoin_cli
 from pisa import HOST, PORT
-from pisa.conf import MAX_APPOINTMENTS
 
 from test.pisa.unit.conftest import (
     generate_block,
@@ -17,6 +16,7 @@ from test.pisa.unit.conftest import (
     get_random_value_hex,
     generate_dummy_appointment_data,
     generate_keypair,
+    get_config,
 )
 
 from common.constants import LOCATOR_LEN_BYTES
@@ -28,6 +28,8 @@ MULTIPLE_APPOINTMENTS = 10
 appointments = []
 locator_dispute_tx_map = {}
 
+config = get_config()
+
 
 @pytest.fixture(scope="module")
 def run_api(db_manager, chain_monitor):
@@ -38,11 +40,11 @@ def run_api(db_manager, chain_monitor):
         encryption_algorithm=serialization.NoEncryption(),
     )
 
-    watcher = Watcher(db_manager, chain_monitor, sk_der)
+    watcher = Watcher(db_manager, chain_monitor, sk_der, get_config())
     chain_monitor.attach_watcher(watcher.block_queue, watcher.asleep)
     chain_monitor.attach_responder(watcher.responder.block_queue, watcher.responder.asleep)
 
-    api_thread = Thread(target=API(watcher).start)
+    api_thread = Thread(target=API(watcher, config).start)
     api_thread.daemon = True
     api_thread.start()
 
@@ -105,7 +107,7 @@ def test_request_multiple_appointments_same_locator(new_appt_data, n=MULTIPLE_AP
 
 
 def test_add_too_many_appointment(new_appt_data):
-    for _ in range(MAX_APPOINTMENTS - len(appointments)):
+    for _ in range(config.get("MAX_APPOINTMENTS") - len(appointments)):
         r = add_appointment(new_appt_data)
         assert r.status_code == 200
 

test/pisa/unit/test_chain_monitor.py

@@ -7,7 +7,7 @@ from pisa.responder import Responder
 from pisa.block_processor import BlockProcessor
 from pisa.chain_monitor import ChainMonitor
 
-from test.pisa.unit.conftest import get_random_value_hex, generate_block
+from test.pisa.unit.conftest import get_random_value_hex, generate_block, get_config
 
 
 def test_init(run_bitcoind):
@@ -30,7 +30,7 @@ def test_init(run_bitcoind):
 
 
 def test_attach_watcher(chain_monitor):
-    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None)
+    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None, config=get_config())
     chain_monitor.attach_watcher(watcher.block_queue, watcher.asleep)
 
     # booleans are not passed as reference in Python, so the flags need to be set separately
@@ -108,7 +108,7 @@ def test_monitor_chain_polling():
     chain_monitor = ChainMonitor()
     chain_monitor.best_tip = BlockProcessor.get_best_block_hash()
 
-    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None)
+    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None, config=get_config())
     chain_monitor.attach_watcher(watcher.block_queue, asleep=False)
 
     # monitor_chain_polling runs until terminate if set
@@ -168,7 +168,7 @@ def test_monitor_chain():
     # Not much to test here, this should launch two threads (one per monitor approach) and finish on terminate
     chain_monitor = ChainMonitor()
 
-    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None)
+    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None, config=get_config())
     responder = Responder(db_manager=None, chain_monitor=chain_monitor)
     chain_monitor.attach_responder(responder.block_queue, asleep=False)
     chain_monitor.attach_watcher(watcher.block_queue, asleep=False)
@@ -198,7 +198,7 @@ def test_monitor_chain_single_update():
     # This test tests that if both threads try to add the same block to the queue, only the first one will make it
     chain_monitor = ChainMonitor()
 
-    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None)
+    watcher = Watcher(db_manager=None, chain_monitor=chain_monitor, sk_der=None, config=get_config())
     responder = Responder(db_manager=None, chain_monitor=chain_monitor)
     chain_monitor.attach_responder(responder.block_queue, asleep=False)
     chain_monitor.attach_watcher(watcher.block_queue, asleep=False)

test/pisa/unit/test_inspector.py

@@ -10,13 +10,13 @@ from common.appointment import Appointment
 from pisa.block_processor import BlockProcessor
 from pisa.conf import MIN_TO_SELF_DELAY
 
-from test.pisa.unit.conftest import get_random_value_hex, generate_dummy_appointment_data, generate_keypair
+from test.pisa.unit.conftest import get_random_value_hex, generate_dummy_appointment_data, generate_keypair, get_config
 
 from common.constants import LOCATOR_LEN_BYTES, LOCATOR_LEN_HEX
 from common.cryptographer import Cryptographer
 
 
-inspector = Inspector()
+inspector = Inspector(get_config())
 APPOINTMENT_OK = (0, None)
 
 NO_HEX_STRINGS = [
@@ -126,21 +126,21 @@ def test_check_to_self_delay():
     # Right value, right format
     to_self_delays = [MIN_TO_SELF_DELAY, MIN_TO_SELF_DELAY + 1, MIN_TO_SELF_DELAY + 1000]
     for to_self_delay in to_self_delays:
-        assert Inspector.check_to_self_delay(to_self_delay) == APPOINTMENT_OK
+        assert inspector.check_to_self_delay(to_self_delay) == APPOINTMENT_OK
 
     # to_self_delay too small
     to_self_delays = [MIN_TO_SELF_DELAY - 1, MIN_TO_SELF_DELAY - 2, 0, -1, -1000]
     for to_self_delay in to_self_delays:
-        assert Inspector.check_to_self_delay(to_self_delay)[0] == APPOINTMENT_FIELD_TOO_SMALL
+        assert inspector.check_to_self_delay(to_self_delay)[0] == APPOINTMENT_FIELD_TOO_SMALL
 
     # Empty field
     to_self_delay = None
-    assert Inspector.check_to_self_delay(to_self_delay)[0] == APPOINTMENT_EMPTY_FIELD
+    assert inspector.check_to_self_delay(to_self_delay)[0] == APPOINTMENT_EMPTY_FIELD
 
     # Wrong data type
     to_self_delays = WRONG_TYPES
     for to_self_delay in to_self_delays:
-        assert Inspector.check_to_self_delay(to_self_delay)[0] == APPOINTMENT_WRONG_FIELD_TYPE
+        assert inspector.check_to_self_delay(to_self_delay)[0] == APPOINTMENT_WRONG_FIELD_TYPE
 
 
 def test_check_blob():

test/pisa/unit/test_pisad.py

@@ -0,0 +1,52 @@
+import importlib
+import os
+import pytest
+from pathlib import Path
+from shutil import copyfile
+
+from pisa.pisad import load_config
+
+test_conf_file_path = os.getcwd() + "/test/pisa/unit/test_conf.py"
+
+
+def test_load_config():
+    # Copy the sample-conf.py file to use as a test config file.
+    copyfile(os.getcwd() + "/pisa/sample_conf.py", test_conf_file_path)
+
+    import test.pisa.unit.test_conf as conf
+
+    # If the file has all the correct fields and data, it should return a dict.
+    conf_dict = load_config(conf)
+    assert type(conf_dict) == dict
+
+    # Delete the file.
+    os.remove(test_conf_file_path)
+
+
+def test_bad_load_config():
+    # Create a messed up version of the file that should throw an error.
+    with open(test_conf_file_path, "w") as f:
+        f.write('# bitcoind\nBTC_RPC_USER = 0000\nBTC_RPC_PASSWD = "password"\nBTC_RPC_HOST = 000')
+
+    import test.pisa.unit.test_conf as conf
+
+    importlib.reload(conf)
+
+    with pytest.raises(Exception):
+        conf_dict = load_config(conf)
+
+    os.remove(test_conf_file_path)
+
+
+def test_empty_load_config():
+    # Create an empty version of the file that should throw an error.
+    open(test_conf_file_path, "a")
+
+    import test.pisa.unit.test_conf as conf
+
+    importlib.reload(conf)
+
+    with pytest.raises(Exception):
+        conf_dict = load_config(conf)
+
+    os.remove(test_conf_file_path)

test/pisa/unit/test_responder.py

@@ -307,10 +307,8 @@ def test_do_watch(temp_db_manager, chain_monitor):
         bitcoin_cli().sendrawtransaction(tracker.penalty_rawtx)
         broadcast_txs.append(tracker.penalty_txid)
 
-    print(responder.unconfirmed_txs)
     # Mine a block
     generate_block()
-    print(responder.unconfirmed_txs)
 
     # The transactions we sent shouldn't be in the unconfirmed transaction list anymore
     assert not set(broadcast_txs).issubset(responder.unconfirmed_txs)

test/pisa/unit/test_watcher.py

@@ -1,15 +1,24 @@
 import pytest
 from uuid import uuid4
 from threading import Thread
+from cryptography.hazmat.primitives.asymmetric import ec
 from cryptography.hazmat.primitives import serialization
 
 from pisa.watcher import Watcher
 from pisa.responder import Responder
 from pisa.tools import bitcoin_cli
-from test.pisa.unit.conftest import generate_blocks, generate_dummy_appointment, get_random_value_hex, generate_keypair
 from pisa.chain_monitor import ChainMonitor
+
+from test.pisa.unit.conftest import (
+    generate_blocks,
+    generate_dummy_appointment,
+    get_random_value_hex,
+    generate_keypair,
+    get_config,
+)
 from pisa.conf import EXPIRY_DELTA, MAX_APPOINTMENTS
 
+from common.tools import compute_locator
 from common.cryptographer import Cryptographer
 
 
@@ -29,7 +38,7 @@ sk_der = signing_key.private_bytes(
 
 @pytest.fixture(scope="module")
 def watcher(db_manager, chain_monitor):
-    watcher = Watcher(db_manager, chain_monitor, sk_der)
+    watcher = Watcher(db_manager, chain_monitor, sk_der, get_config())
     chain_monitor.attach_watcher(watcher.block_queue, watcher.asleep)
     chain_monitor.attach_responder(watcher.responder.block_queue, watcher.responder.asleep)
 
@@ -43,7 +52,7 @@ def txids():
 
 @pytest.fixture(scope="module")
 def locator_uuid_map(txids):
-    return {Watcher.compute_locator(txid): uuid4().hex for txid in txids}
+    return {compute_locator(txid): uuid4().hex for txid in txids}
 
 
 def create_appointments(n):
@@ -67,12 +76,12 @@ def create_appointments(n):
 def test_init(run_bitcoind, watcher):
     assert isinstance(watcher.appointments, dict) and len(watcher.appointments) == 0
     assert isinstance(watcher.locator_uuid_map, dict) and len(watcher.locator_uuid_map) == 0
-    assert isinstance(watcher.chain_monitor, ChainMonitor)
-    assert watcher.block_queue.empty()
     assert watcher.asleep is True
-
-    assert watcher.max_appointments == MAX_APPOINTMENTS
-    assert type(watcher.responder) is Responder
+    assert watcher.block_queue.empty()
+    assert isinstance(watcher.chain_monitor, ChainMonitor)
+    assert isinstance(watcher.config, dict)
+    assert isinstance(watcher.signing_key, ec.EllipticCurvePrivateKey)
+    assert isinstance(watcher.responder, Responder)
 
 
 def test_add_appointment(watcher):
@@ -199,7 +208,7 @@ def test_filter_valid_breaches(watcher):
 
     dummy_appointment, _ = generate_dummy_appointment()
     dummy_appointment.encrypted_blob.data = encrypted_blob
-    dummy_appointment.locator = Watcher.compute_locator(dispute_txid)
+    dummy_appointment.locator = compute_locator(dispute_txid)
     uuid = uuid4().hex
 
     appointments = {uuid: dummy_appointment}