Merge branch 'master' into chainmonitor

test/apps/cli/unit/test_pisa_cli.py

@@ -1,23 +1,41 @@
 import responses
 import json
+import os
+import shutil
 from binascii import hexlify
 
 from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import ec
 
+from common.appointment import Appointment
+from common.cryptographer import Cryptographer
+
 import apps.cli.pisa_cli as pisa_cli
 from test.apps.cli.unit.conftest import get_random_value_hex
 
-# TODO: should find a way of doing without this
-from apps.cli.pisa_cli import build_appointment
-
 # dummy keys for the tests
 pisa_sk = ec.generate_private_key(ec.SECP256K1, default_backend())
 pisa_pk = pisa_sk.public_key()
 
 other_sk = ec.generate_private_key(ec.SECP256K1, default_backend())
 
+pisa_sk_der = pisa_sk.private_bytes(
+    encoding=serialization.Encoding.DER,
+    format=serialization.PrivateFormat.TraditionalOpenSSL,
+    encryption_algorithm=serialization.NoEncryption(),
+)
+pisa_pk_der = pisa_pk.public_bytes(
+    encoding=serialization.Encoding.DER, format=serialization.PublicFormat.SubjectPublicKeyInfo
+)
+
+other_sk_der = other_sk.private_bytes(
+    encoding=serialization.Encoding.DER,
+    format=serialization.PrivateFormat.TraditionalOpenSSL,
+    encryption_algorithm=serialization.NoEncryption(),
+)
+
+
 # Replace the key in the module with a key we control for the tests
 pisa_cli.pisa_public_key = pisa_pk
 # Replace endpoint with dummy one
@@ -32,18 +50,47 @@ dummy_appointment_request = {
     "end_time": 50000,
     "to_self_delay": 200,
 }
-dummy_appointment = build_appointment(**dummy_appointment_request)
 
-# FIXME: USE CRYPTOGRAPHER
+# This is the format appointment turns into once it hits "add_appointment"
+dummy_appointment_full = {
+    "locator": get_random_value_hex(32),
+    "start_time": 1500,
+    "end_time": 50000,
+    "to_self_delay": 200,
+    "encrypted_blob": get_random_value_hex(120),
+}
+
+dummy_appointment = Appointment.from_dict(dummy_appointment_full)
 
 
-def sign_appointment(sk, appointment):
-    data = json.dumps(appointment, sort_keys=True, separators=(",", ":")).encode("utf-8")
-    return hexlify(sk.sign(data, ec.ECDSA(hashes.SHA256()))).decode("utf-8")
+def get_dummy_pisa_sk_der(*args):
+    return pisa_sk_der
 
 
-def get_dummy_pisa_pk(der_data):
-    return pisa_pk
+def get_dummy_pisa_pk_der(*args):
+    return pisa_pk_der
+
+
+def get_dummy_hex_pk_der(*args):
+    return hexlify(get_dummy_pisa_pk_der())
+
+
+def get_dummy_signature(*args):
+    sk = Cryptographer.load_private_key_der(pisa_sk_der)
+    return Cryptographer.sign(dummy_appointment.serialize(), sk)
+
+
+def get_bad_signature(*args):
+    sk = Cryptographer.load_private_key_der(other_sk_der)
+    return Cryptographer.sign(dummy_appointment.serialize(), sk)
+
+
+def valid_sig(*args):
+    return True
+
+
+def invalid_sig(*args):
+    return False
 
 
 @responses.activate
@@ -51,10 +98,12 @@ def test_add_appointment(monkeypatch):
     # Simulate a request to add_appointment for dummy_appointment, make sure that the right endpoint is requested
     # and the return value is True
 
-    # make sure the test uses the right dummy key instead of loading it from disk
-    monkeypatch.setattr(pisa_cli, "load_public_key", get_dummy_pisa_pk)
+    # Make sure the test uses the dummy signature
+    monkeypatch.setattr(pisa_cli, "get_appointment_signature", get_dummy_signature)
+    monkeypatch.setattr(pisa_cli, "get_pk", get_dummy_hex_pk_der)
+    monkeypatch.setattr(pisa_cli, "check_signature", valid_sig)
 
-    response = {"locator": dummy_appointment["locator"], "signature": sign_appointment(pisa_sk, dummy_appointment)}
+    response = {"locator": dummy_appointment.to_dict()["locator"], "signature": get_dummy_signature()}
 
     request_url = "http://{}/".format(pisa_endpoint)
     responses.add(responses.POST, request_url, json=response, status=200)
@@ -72,12 +121,14 @@ def test_add_appointment_with_invalid_signature(monkeypatch):
     # Simulate a request to add_appointment for dummy_appointment, but sign with a different key,
     # make sure that the right endpoint is requested, but the return value is False
 
-    # make sure the test uses the right dummy key instead of loading it from disk
-    monkeypatch.setattr(pisa_cli, "load_public_key", get_dummy_pisa_pk)
+    # Make sure the test uses the bad dummy signature
+    monkeypatch.setattr(pisa_cli, "get_appointment_signature", get_bad_signature)
+    monkeypatch.setattr(pisa_cli, "get_pk", get_dummy_hex_pk_der)
+    monkeypatch.setattr(pisa_cli, "check_signature", invalid_sig)
 
     response = {
-        "locator": dummy_appointment["locator"],
-        "signature": sign_appointment(other_sk, dummy_appointment),  # signing with a different key
+        "locator": dummy_appointment.to_dict()["locator"],
+        "signature": get_bad_signature(),  # Sign with a bad key
     }
 
     request_url = "http://{}/".format(pisa_endpoint)
@@ -85,4 +136,141 @@ def test_add_appointment_with_invalid_signature(monkeypatch):
 
     result = pisa_cli.add_appointment([json.dumps(dummy_appointment_request)])
 
-    assert not result
+    assert result is False
+
+
+def test_load_key_file_data():
+    # If file exists and has data in it, function should work.
+    with open("key_test_file", "w+b") as f:
+        f.write(pisa_sk_der)
+
+    appt_data = pisa_cli.load_key_file_data("key_test_file")
+    assert appt_data
+
+    os.remove("key_test_file")
+
+    # If file doesn't exist, function should fail.
+    appt_data = pisa_cli.load_key_file_data("nonexistent_file")
+    assert not appt_data
+
+
+def test_save_signed_appointment(monkeypatch):
+    monkeypatch.setattr(pisa_cli, "APPOINTMENTS_FOLDER_NAME", "test_appointments")
+
+    pisa_cli.save_signed_appointment(dummy_appointment.to_dict(), get_dummy_signature())
+
+    # In folder "Appointments," grab all files and print them.
+    files = os.listdir("test_appointments")
+
+    found = False
+    for f in files:
+        if dummy_appointment.to_dict().get("locator") in f:
+            found = True
+
+    assert found
+
+    # If "appointments" directory doesn't exist, function should create it.
+    assert os.path.exists("test_appointments")
+
+    # Delete test directory once we're done.
+    shutil.rmtree("test_appointments")
+
+
+def test_parse_add_appointment_args():
+    # If no args are passed, function should fail.
+    appt_data = pisa_cli.parse_add_appointment_args(None)
+    assert not appt_data
+
+    # If file doesn't exist, function should fail.
+    appt_data = pisa_cli.parse_add_appointment_args(["-f", "nonexistent_file"])
+    assert not appt_data
+
+    # If file exists and has data in it, function should work.
+    with open("appt_test_file", "w") as f:
+        json.dump(dummy_appointment_request, f)
+
+    appt_data = pisa_cli.parse_add_appointment_args(["-f", "appt_test_file"])
+    assert appt_data
+
+    os.remove("appt_test_file")
+
+    # If appointment json is passed in, function should work.
+    appt_data = pisa_cli.parse_add_appointment_args([json.dumps(dummy_appointment_request)])
+    assert appt_data
+
+
+@responses.activate
+def test_post_data_to_add_appointment_endpoint():
+    response = {
+        "locator": dummy_appointment.to_dict()["locator"],
+        "signature": Cryptographer.sign(dummy_appointment.serialize(), pisa_sk),
+    }
+
+    request_url = "http://{}/".format(pisa_endpoint)
+    responses.add(responses.POST, request_url, json=response, status=200)
+
+    response = pisa_cli.post_data_to_add_appointment_endpoint(request_url, json.dumps(dummy_appointment_request))
+
+    assert len(responses.calls) == 1
+    assert responses.calls[0].request.url == request_url
+
+    assert response
+
+
+def test_check_signature(monkeypatch):
+    # Make sure the test uses the right dummy key instead of loading it from disk
+    monkeypatch.setattr(pisa_cli, "load_key_file_data", get_dummy_pisa_pk_der)
+
+    valid = pisa_cli.check_signature(get_dummy_signature(), dummy_appointment)
+
+    assert valid
+
+    valid = pisa_cli.check_signature(get_bad_signature(), dummy_appointment)
+
+    assert not valid
+
+
+@responses.activate
+def test_get_appointment():
+    # Response of get_appointment endpoint is an appointment with status added to it.
+    dummy_appointment_full["status"] = "being_watched"
+    response = dummy_appointment_full
+
+    request_url = "http://{}/".format(pisa_endpoint) + "get_appointment?locator={}".format(response.get("locator"))
+    responses.add(responses.GET, request_url, json=response, status=200)
+
+    result = pisa_cli.get_appointment([response.get("locator")])
+
+    assert len(responses.calls) == 1
+    assert responses.calls[0].request.url == request_url
+
+    assert result
+
+
+@responses.activate
+def test_get_appointment_err():
+    locator = get_random_value_hex(32)
+
+    # Test that get_appointment handles a connection error appropriately.
+    request_url = "http://{}/".format(pisa_endpoint) + "get_appointment?locator=".format(locator)
+    responses.add(responses.GET, request_url, body=ConnectionError())
+
+    assert not pisa_cli.get_appointment([locator])
+
+
+def test_get_appointment_signature(monkeypatch):
+    # Make sure the test uses the right dummy key instead of loading it from disk
+    monkeypatch.setattr(pisa_cli, "load_key_file_data", get_dummy_pisa_sk_der)
+
+    signature = pisa_cli.get_appointment_signature(dummy_appointment)
+
+    assert isinstance(signature, str)
+
+
+def test_get_pk(monkeypatch):
+    # Make sure the test uses the right dummy key instead of loading it from disk
+    monkeypatch.setattr(pisa_cli, "load_key_file_data", get_dummy_pisa_pk_der)
+
+    pk = pisa_cli.get_pk()
+
+    assert isinstance(pk, bytes)

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}