From 7aa74d59530f1c4d4087d2a0b976b03c1fdf7c99 Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Mon, 23 Dec 2019 21:48:45 -0500
Subject: [PATCH 1/8] Move config options used by watcher and responder to the
 constructor

---
 pisa/pisad.py                    | 17 ++++++++++++++---
 pisa/responder.py                |  5 +++--
 pisa/utils/zmq_subscriber.py     |  6 ++++--
 pisa/watcher.py                  | 13 ++++++-------
 test/pisa/unit/conftest.py       | 23 +++++++++++++++++++++++
 test/pisa/unit/test_api.py       |  5 +++--
 test/pisa/unit/test_responder.py | 15 ++++++++-------
 test/pisa/unit/test_watcher.py   |  5 +++--
 8 files changed, 64 insertions(+), 25 deletions(-)

diff --git a/pisa/pisad.py b/pisa/pisad.py
index 9c258ce..c5b8dff 100644
--- a/pisa/pisad.py
+++ b/pisa/pisad.py
@@ -7,7 +7,16 @@ from common.logger import Logger
 from pisa.api import API
 from pisa.watcher import Watcher
 from pisa.builder import Builder
-from pisa.conf import BTC_NETWORK, PISA_SECRET_KEY
+from pisa.conf import (
+    BTC_NETWORK,
+    FEED_PROTOCOL,
+    FEED_ADDR,
+    FEED_PORT,
+    MAX_APPOINTMENTS,
+    EXPIRY_DELTA,
+    MIN_TO_SELF_DELAY,
+    PISA_SECRET_KEY,
+)
 from pisa.responder import Responder
 from pisa.db_manager import DBManager
 from pisa.block_processor import BlockProcessor
@@ -52,7 +61,9 @@ if __name__ == "__main__":
             with open(PISA_SECRET_KEY, "rb") as key_file:
                 secret_key_der = key_file.read()
 
-            watcher = Watcher(db_manager, secret_key_der)
+            pisa_config = load_config(conf)
+
+            watcher = Watcher(db_manager, secret_key_der, config=pisa_config)
 
             if len(watcher_appointments_data) == 0 and len(responder_trackers_data) == 0:
                 logger.info("Fresh bootstrap")
@@ -65,7 +76,7 @@ if __name__ == "__main__":
                 last_block_responder = db_manager.load_last_block_hash_responder()
 
                 # FIXME: 32-reorgs-offline dropped txs are not used at this point.
-                responder = Responder(db_manager)
+                responder = Responder(db_manager, pisa_config)
                 last_common_ancestor_responder = None
                 missed_blocks_responder = None
 
diff --git a/pisa/responder.py b/pisa/responder.py
index 0fce1cb..2d856e4 100644
--- a/pisa/responder.py
+++ b/pisa/responder.py
@@ -135,13 +135,14 @@ class Responder:
 
     """
 
-    def __init__(self, db_manager):
+    def __init__(self, db_manager, config):
         self.trackers = dict()
         self.tx_tracker_map = dict()
         self.unconfirmed_txs = []
         self.missed_confirmations = dict()
         self.asleep = True
         self.block_queue = Queue()
+        self.config = config
         self.zmq_subscriber = None
         self.db_manager = db_manager
 
@@ -271,7 +272,7 @@ class Responder:
         from ``bitcoind``. Block ids are received trough the ``block_queue``.
         """
 
-        self.zmq_subscriber = ZMQSubscriber(parent="Responder")
+        self.zmq_subscriber = ZMQSubscriber(self.config, parent="Responder")
         self.zmq_subscriber.handle(self.block_queue)
 
     def do_watch(self):
diff --git a/pisa/utils/zmq_subscriber.py b/pisa/utils/zmq_subscriber.py
index ecec9af..5bf29f5 100644
--- a/pisa/utils/zmq_subscriber.py
+++ b/pisa/utils/zmq_subscriber.py
@@ -8,12 +8,14 @@ from pisa.conf import FEED_PROTOCOL, FEED_ADDR, FEED_PORT
 class ZMQSubscriber:
     """ Adapted from https://github.com/bitcoin/bitcoin/blob/master/contrib/zmq/zmq_sub.py"""
 
-    def __init__(self, parent):
+    def __init__(self, config, parent):
         self.zmqContext = zmq.Context()
         self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
         self.zmqSubSocket.setsockopt(zmq.RCVHWM, 0)
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashblock")
-        self.zmqSubSocket.connect("%s://%s:%s" % (FEED_PROTOCOL, FEED_ADDR, FEED_PORT))
+        self.zmqSubSocket.connect(
+            "%s://%s:%s" % (config.get("FEED_PROTOCOL"), config.get("FEED_ADDR"), config.get("FEED_PORT"))
+        )
         self.logger = Logger("ZMQSubscriber-{}".format(parent))
 
         self.terminate = False
diff --git a/pisa/watcher.py b/pisa/watcher.py
index 9d659db..356c707 100644
--- a/pisa/watcher.py
+++ b/pisa/watcher.py
@@ -10,7 +10,6 @@ from pisa.cleaner import Cleaner
 from pisa.responder import Responder
 from pisa.block_processor import BlockProcessor
 from pisa.utils.zmq_subscriber import ZMQSubscriber
-from pisa.conf import EXPIRY_DELTA, MAX_APPOINTMENTS
 
 logger = Logger("Watcher")
 
@@ -58,18 +57,18 @@ class Watcher:
 
     """
 
-    def __init__(self, db_manager, sk_der, responder=None, max_appointments=MAX_APPOINTMENTS):
+    def __init__(self, db_manager, sk_der, config, responder=None):
         self.appointments = dict()
         self.locator_uuid_map = dict()
         self.asleep = True
         self.block_queue = Queue()
-        self.max_appointments = max_appointments
+        self.config = config
         self.zmq_subscriber = None
         self.db_manager = db_manager
         self.signing_key = Cryptographer.load_private_key_der(sk_der)
 
         if not isinstance(responder, Responder):
-            self.responder = Responder(db_manager)
+            self.responder = Responder(db_manager, self.config)
 
     @staticmethod
     def compute_locator(tx_id):
@@ -115,7 +114,7 @@ class Watcher:
 
         """
 
-        if len(self.appointments) < self.max_appointments:
+        if len(self.appointments) < self.config.get("MAX_APPOINTMENTS"):
             uuid = uuid4().hex
             self.appointments[uuid] = appointment
 
@@ -157,7 +156,7 @@ class Watcher:
         trough the ``block_queue``.
         """
 
-        self.zmq_subscriber = ZMQSubscriber(parent="Watcher")
+        self.zmq_subscriber = ZMQSubscriber(self.config, parent="Watcher")
         self.zmq_subscriber.handle(self.block_queue)
 
     def do_watch(self):
@@ -182,7 +181,7 @@ class Watcher:
                 expired_appointments = [
                     uuid
                     for uuid, appointment in self.appointments.items()
-                    if block["height"] > appointment.end_time + EXPIRY_DELTA
+                    if block["height"] > appointment.end_time + self.config.get("EXPIRY_DELTA")
                 ]
 
                 Cleaner.delete_expired_appointment(
diff --git a/test/pisa/unit/conftest.py b/test/pisa/unit/conftest.py
index 4ff9028..41a9540 100644
--- a/test/pisa/unit/conftest.py
+++ b/test/pisa/unit/conftest.py
@@ -147,3 +147,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
diff --git a/test/pisa/unit/test_api.py b/test/pisa/unit/test_api.py
index 2dc830b..75c5f8f 100644
--- a/test/pisa/unit/test_api.py
+++ b/test/pisa/unit/test_api.py
@@ -9,7 +9,7 @@ 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 pisa.conf import MAX_APPOINTMENTS, EXPIRY_DELTA
 
 from test.pisa.unit.conftest import (
     generate_block,
@@ -17,6 +17,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
@@ -37,7 +38,7 @@ def run_api(db_manager):
         format=serialization.PrivateFormat.TraditionalOpenSSL,
         encryption_algorithm=serialization.NoEncryption(),
     )
-    watcher = Watcher(db_manager, sk_der)
+    watcher = Watcher(db_manager, sk_der, get_config())
 
     api_thread = Thread(target=API(watcher).start)
     api_thread.daemon = True
diff --git a/test/pisa/unit/test_responder.py b/test/pisa/unit/test_responder.py
index a9e99da..ddd8105 100644
--- a/test/pisa/unit/test_responder.py
+++ b/test/pisa/unit/test_responder.py
@@ -17,12 +17,12 @@ from common.tools import check_sha256_hex_format
 
 from bitcoind_mock.utils import sha256d
 from bitcoind_mock.transaction import TX
-from test.pisa.unit.conftest import generate_block, generate_blocks, get_random_value_hex
+from test.pisa.unit.conftest import generate_block, generate_blocks, get_random_value_hex, get_config
 
 
 @pytest.fixture(scope="module")
 def responder(db_manager):
-    return Responder(db_manager)
+    return Responder(db_manager, get_config())
 
 
 @pytest.fixture()
@@ -151,11 +151,12 @@ def test_init_responder(responder):
     assert type(responder.missed_confirmations) is dict and len(responder.missed_confirmations) == 0
     assert responder.block_queue.empty()
     assert responder.asleep is True
+    assert type(responder.config) is dict
     assert responder.zmq_subscriber is None
 
 
 def test_handle_breach(db_manager):
-    responder = Responder(db_manager)
+    responder = Responder(db_manager, get_config())
     uuid = uuid4().hex
     tracker = create_dummy_tracker()
 
@@ -295,7 +296,7 @@ def test_do_subscribe(responder):
 
 
 def test_do_watch(temp_db_manager):
-    responder = Responder(temp_db_manager)
+    responder = Responder(temp_db_manager, get_config())
     responder.block_queue = Queue()
 
     zmq_thread = Thread(target=responder.do_subscribe)
@@ -351,7 +352,7 @@ def test_do_watch(temp_db_manager):
 
 
 def test_check_confirmations(temp_db_manager):
-    responder = Responder(temp_db_manager)
+    responder = Responder(temp_db_manager, get_config())
     responder.block_queue = Queue()
 
     zmq_thread = Thread(target=responder.do_subscribe)
@@ -414,7 +415,7 @@ def test_get_completed_trackers(db_manager):
     initial_height = bitcoin_cli().getblockcount()
 
     # Let's use a fresh responder for this to make it easier to compare the results
-    responder = Responder(db_manager)
+    responder = Responder(db_manager, get_config())
 
     # A complete tracker is a tracker that has reached the appointment end with enough confirmations (> MIN_CONFIRMATIONS)
     # We'll create three type of transactions: end reached + enough conf, end reached + no enough conf, end not reached
@@ -462,7 +463,7 @@ def test_get_completed_trackers(db_manager):
 
 
 def test_rebroadcast(db_manager):
-    responder = Responder(db_manager)
+    responder = Responder(db_manager, get_config())
     responder.asleep = False
 
     txs_to_rebroadcast = []
diff --git a/test/pisa/unit/test_watcher.py b/test/pisa/unit/test_watcher.py
index 8ec331c..bb94c60 100644
--- a/test/pisa/unit/test_watcher.py
+++ b/test/pisa/unit/test_watcher.py
@@ -13,6 +13,7 @@ from test.pisa.unit.conftest import (
     generate_dummy_appointment,
     get_random_value_hex,
     generate_keypair,
+    get_config,
 )
 from pisa.conf import EXPIRY_DELTA, MAX_APPOINTMENTS
 
@@ -36,7 +37,7 @@ sk_der = signing_key.private_bytes(
 
 @pytest.fixture(scope="module")
 def watcher(db_manager):
-    return Watcher(db_manager, sk_der)
+    return Watcher(db_manager, sk_der, get_config())
 
 
 @pytest.fixture(scope="module")
@@ -72,7 +73,7 @@ def test_init(watcher):
     assert type(watcher.locator_uuid_map) is dict and len(watcher.locator_uuid_map) == 0
     assert watcher.block_queue.empty()
     assert watcher.asleep is True
-    assert watcher.max_appointments == MAX_APPOINTMENTS
+    assert type(watcher.config) is dict
     assert watcher.zmq_subscriber is None
     assert type(watcher.responder) is Responder
 

From c22bf220f0e7ff7a0b070c0851fae0a654932884 Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Mon, 23 Dec 2019 22:40:33 -0500
Subject: [PATCH 2/8] Move config options used by inspector to the constructor

---
 pisa/api.py                      |  5 +++--
 pisa/inspector.py                | 11 ++++++-----
 pisa/pisad.py                    | 13 ++-----------
 test/pisa/unit/test_api.py       |  7 ++++---
 test/pisa/unit/test_inspector.py | 12 ++++++------
 5 files changed, 21 insertions(+), 27 deletions(-)

diff --git a/pisa/api.py b/pisa/api.py
index 9468166..ec8dbda 100644
--- a/pisa/api.py
+++ b/pisa/api.py
@@ -17,8 +17,9 @@ logger = Logger("API")
 
 
 class API:
-    def __init__(self, watcher):
+    def __init__(self, watcher, config):
         self.watcher = watcher
+        self.config = config
 
     def add_appointment(self):
         """
@@ -41,7 +42,7 @@ class API:
 
         # Check content type once if properly defined
         request_data = json.loads(request.get_json())
-        inspector = Inspector()
+        inspector = Inspector(self.config)
         appointment = inspector.inspect(
             request_data.get("appointment"), request_data.get("signature"), request_data.get("public_key")
         )
diff --git a/pisa/inspector.py b/pisa/inspector.py
index 00a7fc2..fcc570e 100644
--- a/pisa/inspector.py
+++ b/pisa/inspector.py
@@ -5,7 +5,6 @@ from common.constants import LOCATOR_LEN_HEX
 from common.cryptographer import Cryptographer
 
 from pisa import errors
-import pisa.conf as conf
 from common.logger import Logger
 from common.appointment import Appointment
 from pisa.block_processor import BlockProcessor
@@ -23,6 +22,9 @@ class Inspector:
     The :class:`Inspector` class is in charge of verifying that the appointment data provided by the user is correct.
     """
 
+    def __init__(self, config):
+        self.config = config
+
     def inspect(self, appointment_data, signature, public_key):
         """
         Inspects whether the data provided by the user is correct.
@@ -221,8 +223,7 @@ class Inspector:
 
         return rcode, message
 
-    @staticmethod
-    def check_to_self_delay(to_self_delay):
+    def check_to_self_delay(self, to_self_delay):
         """
         Checks if the provided ``to_self_delay`` is correct.
 
@@ -255,10 +256,10 @@ class Inspector:
             rcode = errors.APPOINTMENT_WRONG_FIELD_TYPE
             message = "wrong to_self_delay data type ({})".format(t)
 
-        elif to_self_delay < conf.MIN_TO_SELF_DELAY:
+        elif to_self_delay < self.config.get("MIN_TO_SELF_DELAY"):
             rcode = errors.APPOINTMENT_FIELD_TOO_SMALL
             message = "to_self_delay too small. The to_self_delay should be at least {} (current: {})".format(
-                conf.MIN_TO_SELF_DELAY, to_self_delay
+                self.config.get("MIN_TO_SELF_DELAY"), to_self_delay
             )
 
         if message is not None:
diff --git a/pisa/pisad.py b/pisa/pisad.py
index c5b8dff..be9d571 100644
--- a/pisa/pisad.py
+++ b/pisa/pisad.py
@@ -7,16 +7,7 @@ from common.logger import Logger
 from pisa.api import API
 from pisa.watcher import Watcher
 from pisa.builder import Builder
-from pisa.conf import (
-    BTC_NETWORK,
-    FEED_PROTOCOL,
-    FEED_ADDR,
-    FEED_PORT,
-    MAX_APPOINTMENTS,
-    EXPIRY_DELTA,
-    MIN_TO_SELF_DELAY,
-    PISA_SECRET_KEY,
-)
+import pisa.conf as conf
 from pisa.responder import Responder
 from pisa.db_manager import DBManager
 from pisa.block_processor import BlockProcessor
@@ -108,7 +99,7 @@ if __name__ == "__main__":
                     watcher.block_queue = Builder.build_block_queue(missed_blocks_watcher)
 
             # Fire the API
-            API(watcher).start()
+            API(watcher, config=pisa_config).start()
 
         except Exception as e:
             logger.error("An error occurred: {}. Shutting down".format(e))
diff --git a/test/pisa/unit/test_api.py b/test/pisa/unit/test_api.py
index 75c5f8f..820b11a 100644
--- a/test/pisa/unit/test_api.py
+++ b/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, EXPIRY_DELTA
 
 from test.pisa.unit.conftest import (
     generate_block,
@@ -29,6 +28,8 @@ MULTIPLE_APPOINTMENTS = 10
 appointments = []
 locator_dispute_tx_map = {}
 
+config = get_config()
+
 
 @pytest.fixture(scope="module")
 def run_api(db_manager):
@@ -40,7 +41,7 @@ def run_api(db_manager):
     )
     watcher = Watcher(db_manager, sk_der, get_config())
 
-    api_thread = Thread(target=API(watcher).start)
+    api_thread = Thread(target=API(watcher, config).start)
     api_thread.daemon = True
     api_thread.start()
 
@@ -103,7 +104,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
 
diff --git a/test/pisa/unit/test_inspector.py b/test/pisa/unit/test_inspector.py
index 7b18460..4dbafce 100644
--- a/test/pisa/unit/test_inspector.py
+++ b/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():

From e22bd8953457ee446fdbbaf496aa89f61304ac3e Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Mon, 6 Jan 2020 01:07:22 -0500
Subject: [PATCH 3/8] Test load_config functions

---
 test/pisa/unit/test_pisad.py | 52 ++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 test/pisa/unit/test_pisad.py

diff --git a/test/pisa/unit/test_pisad.py b/test/pisa/unit/test_pisad.py
new file mode 100644
index 0000000..fae1d85
--- /dev/null
+++ b/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)

From 1188ddda17d11b9261acc89c03bc99a0a7113902 Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Mon, 6 Jan 2020 01:08:23 -0500
Subject: [PATCH 4/8] Add load_config function

---
 pisa/pisad.py | 58 +++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 52 insertions(+), 6 deletions(-)

diff --git a/pisa/pisad.py b/pisa/pisad.py
index be9d571..5e84a72 100644
--- a/pisa/pisad.py
+++ b/pisa/pisad.py
@@ -2,7 +2,6 @@ from getopt import getopt
 from sys import argv, exit
 from signal import signal, SIGINT, SIGQUIT, SIGTERM
 
-from pisa.conf import DB_PATH
 from common.logger import Logger
 from pisa.api import API
 from pisa.watcher import Watcher
@@ -24,6 +23,53 @@ def handle_signals(signal_received, frame):
     exit(0)
 
 
+def load_config(config):
+    """
+    Looks through all of the config options to make sure they contain the right type of data and builds a config
+    dictionary. 
+
+    Args:
+        config (:obj:`module`): It takes in a config module object.
+
+    Returns:
+        :obj:`dict` A dictionary containing the config values.
+    """
+
+    conf_dict = {}
+
+    conf_fields = {
+        "BTC_RPC_USER": {"value": config.BTC_RPC_USER, "type": str},
+        "BTC_RPC_PASSWD": {"value": config.BTC_RPC_PASSWD, "type": str},
+        "BTC_RPC_HOST": {"value": config.BTC_RPC_HOST, "type": str},
+        "BTC_RPC_PORT": {"value": config.BTC_RPC_PORT, "type": int},
+        "BTC_NETWORK": {"value": config.BTC_NETWORK, "type": str},
+        "FEED_PROTOCOL": {"value": config.FEED_PROTOCOL, "type": str},
+        "FEED_ADDR": {"value": config.FEED_ADDR, "type": str},
+        "FEED_PORT": {"value": config.FEED_PORT, "type": int},
+        "MAX_APPOINTMENTS": {"value": config.MAX_APPOINTMENTS, "type": int},
+        "EXPIRY_DELTA": {"value": config.EXPIRY_DELTA, "type": int},
+        "MIN_TO_SELF_DELAY": {"value": config.MIN_TO_SELF_DELAY, "type": int},
+        "SERVER_LOG_FILE": {"value": config.SERVER_LOG_FILE, "type": str},
+        "PISA_SECRET_KEY": {"value": config.PISA_SECRET_KEY, "type": str},
+        "CLIENT_LOG_FILE": {"value": config.CLIENT_LOG_FILE, "type": str},
+        "TEST_LOG_FILE": {"value": config.TEST_LOG_FILE, "type": str},
+        "DB_PATH": {"value": config.DB_PATH, "type": str},
+    }
+
+    for field in conf_fields:
+        value = conf_fields[field]["value"]
+        correct_type = conf_fields[field]["type"]
+
+        if (value is not None) and isinstance(value, correct_type):
+            conf_dict[field] = value
+        else:
+            err_msg = "{} variable in config is of the wrong type".format(field)
+            logger.error(err_msg)
+            raise ValueError(err_msg)
+
+    return conf_dict
+
+
 if __name__ == "__main__":
     logger.info("Starting PISA")
 
@@ -36,24 +82,24 @@ if __name__ == "__main__":
         # FIXME: Leaving this here for future option/arguments
         pass
 
+    pisa_config = load_config(conf)
+
     if not can_connect_to_bitcoind():
         logger.error("Can't connect to bitcoind. Shutting down")
 
-    elif not in_correct_network(BTC_NETWORK):
+    elif not in_correct_network(pisa_config.get("BTC_NETWORK")):
         logger.error("bitcoind is running on a different network, check conf.py and bitcoin.conf. Shutting down")
 
     else:
         try:
-            db_manager = DBManager(DB_PATH)
+            db_manager = DBManager(pisa_config.get("DB_PATH"))
 
             watcher_appointments_data = db_manager.load_watcher_appointments()
             responder_trackers_data = db_manager.load_responder_trackers()
 
-            with open(PISA_SECRET_KEY, "rb") as key_file:
+            with open(pisa_config.get("PISA_SECRET_KEY"), "rb") as key_file:
                 secret_key_der = key_file.read()
 
-            pisa_config = load_config(conf)
-
             watcher = Watcher(db_manager, secret_key_der, config=pisa_config)
 
             if len(watcher_appointments_data) == 0 and len(responder_trackers_data) == 0:

From 40d7ca1912e06dc9eae12ccace43db538add3f4c Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Sat, 30 Nov 2019 00:42:36 -0500
Subject: [PATCH 5/8] Refactor add_appointment cli code

---
 apps/cli/pisa_cli.py           | 228 ++++++++++++++++++++-------------
 common/tools.py                |  13 ++
 pisa/watcher.py                |  18 +--
 test/pisa/unit/conftest.py     |   3 +-
 test/pisa/unit/test_watcher.py |   6 +-
 5 files changed, 162 insertions(+), 106 deletions(-)

diff --git a/apps/cli/pisa_cli.py b/apps/cli/pisa_cli.py
index 0f2eb92..440860d 100644
--- a/apps/cli/pisa_cli.py
+++ b/apps/cli/pisa_cli.py
@@ -9,8 +9,8 @@ from getopt import getopt, GetoptError
 from requests import ConnectTimeout, ConnectionError
 from uuid import uuid4
 
-from apps.cli.blob import Blob
 from apps.cli.help import help_add_appointment, help_get_appointment
+from apps.cli.blob import Blob
 from apps.cli import (
     DEFAULT_PISA_API_SERVER,
     DEFAULT_PISA_API_PORT,
@@ -22,9 +22,8 @@ from apps.cli import (
 
 from common.logger import Logger
 from common.appointment import Appointment
-from common.constants import LOCATOR_LEN_HEX
 from common.cryptographer import Cryptographer
-from common.tools import check_sha256_hex_format
+from common.tools import check_sha256_hex_format, compute_locator
 
 
 HTTP_OK = 200
@@ -46,11 +45,13 @@ def generate_dummy_appointment():
         "to_self_delay": 20,
     }
 
-    print("Generating dummy appointment data:" "\n\n" + json.dumps(dummy_appointment_data, indent=4, sort_keys=True))
+    logger.info(
+        "Generating dummy appointment data:" "\n\n" + json.dumps(dummy_appointment_data, indent=4, sort_keys=True)
+    )
 
     json.dump(dummy_appointment_data, open("dummy_appointment_data.json", "w"))
 
-    print("\nData stored in dummy_appointment_data.json")
+    logger.info("\nData stored in dummy_appointment_data.json")
 
 
 # Loads and returns Pisa keys from disk
@@ -61,11 +62,12 @@ def load_key_file_data(file_name):
         return key
 
     except FileNotFoundError:
-        raise FileNotFoundError("File not found.")
+        logger.error("Client's key file not found. Please check your settings.")
+        return False
 
-
-def compute_locator(tx_id):
-    return tx_id[:LOCATOR_LEN_HEX]
+    except IOError as e:
+        logger.error("I/O error({}): {}".format(e.errno, e.strerror))
+        return False
 
 
 # Makes sure that the folder APPOINTMENTS_FOLDER_NAME exists, then saves the appointment and signature in it.
@@ -85,12 +87,81 @@ def save_signed_appointment(appointment, signature):
 
 
 def add_appointment(args):
-    appointment_data = None
+    # Get appointment data from user.
+    appointment_data = parse_add_appointment_args(args)
+
+    if appointment_data is None:
+        logger.error("The provided appointment JSON is empty")
+        return False
+
+    valid_txid = check_sha256_hex_format(appointment_data.get("tx_id"))
+
+    if not valid_txid:
+        logger.error("The provided txid is not valid")
+        return False
+
+    tx_id = appointment_data.get("tx_id")
+    tx = appointment_data.get("tx")
+
+    if None not in [tx_id, tx]:
+        appointment_data["locator"] = compute_locator(tx_id)
+        appointment_data["encrypted_blob"] = Cryptographer.encrypt(Blob(tx), tx_id)
+
+    else:
+        logger.error("Appointment data is missing some fields.")
+        return False
+
+    appointment = Appointment.from_dict(appointment_data)
+
+    signature = get_appointment_signature(appointment)
+    hex_pk_der = get_pk()
+
+    if not (appointment and signature and hex_pk_der):
+        return False
+
+    data = {"appointment": appointment.to_dict(), "signature": signature, "public_key": hex_pk_der.decode("utf-8")}
+
+    appointment_json = json.dumps(data, sort_keys=True, separators=(",", ":"))
+
+    # Send appointment to the server.
+    add_appointment_endpoint = "http://{}:{}".format(pisa_api_server, pisa_api_port)
+    response_json = post_data_to_add_appointment_endpoint(add_appointment_endpoint, appointment_json)
+
+    if response_json is None:
+        return False
+
+    signature = response_json.get("signature")
+    # Check that the server signed the appointment as it should.
+    if signature is None:
+        logger.error("The response does not contain the signature of the appointment.")
+        return False
+
+    valid = check_signature(signature, appointment)
+
+    if not valid:
+        logger.error("The returned appointment's signature is invalid")
+        return False
+
+    logger.info("Appointment accepted and signed by Pisa")
+    # all good, store appointment and signature
+    try:
+        save_signed_appointment(appointment.to_dict(), signature)
+
+    except OSError as e:
+        logger.error("There was an error while saving the appointment", error=e)
+        return False
+
+    return True
+
+
+# Parse arguments passed to add_appointment and handle them accordingly.
+# Returns appointment data.
+def parse_add_appointment_args(args):
     use_help = "Use 'help add_appointment' for help of how to use the command"
 
     if not args:
         logger.error("No appointment data provided. " + use_help)
-        return False
+        return None
 
     arg_opt = args.pop(0)
 
@@ -102,7 +173,7 @@ def add_appointment(args):
             fin = args.pop(0)
             if not os.path.isfile(fin):
                 logger.error("Can't find file", filename=fin)
-                return False
+                return None
 
             try:
                 with open(fin) as f:
@@ -110,63 +181,19 @@ def add_appointment(args):
 
             except IOError as e:
                 logger.error("I/O error", errno=e.errno, error=e.strerror)
-                return False
+                return None
         else:
             appointment_data = json.loads(arg_opt)
 
     except json.JSONDecodeError:
         logger.error("Non-JSON encoded data provided as appointment. " + use_help)
-        return False
+        return None
 
-    if not appointment_data:
-        logger.error("The provided JSON is empty")
-        return False
+    return appointment_data
 
-    valid_locator = check_sha256_hex_format(appointment_data.get("tx_id"))
-
-    if not valid_locator:
-        logger.error("The provided locator is not valid")
-        return False
-
-    add_appointment_endpoint = "http://{}:{}".format(pisa_api_server, pisa_api_port)
-    appointment = Appointment.from_dict(appointment_data)
-
-    try:
-        sk_der = load_key_file_data(CLI_PRIVATE_KEY)
-        cli_sk = Cryptographer.load_private_key_der(sk_der)
-
-    except ValueError:
-        logger.error("Failed to deserialize the public key. It might be in an unsupported format")
-        return False
-
-    except FileNotFoundError:
-        logger.error("Client's private key file not found. Please check your settings")
-        return False
-
-    except IOError as e:
-        logger.error("I/O error", errno=e.errno, error=e.strerror)
-        return False
-
-    signature = Cryptographer.sign(appointment.serialize(), cli_sk)
-
-    try:
-        cli_pk_der = load_key_file_data(CLI_PUBLIC_KEY)
-        hex_pk_der = binascii.hexlify(cli_pk_der)
-
-    except FileNotFoundError:
-        logger.error("Client's public key file not found. Please check your settings")
-        return False
-
-    except IOError as e:
-        logger.error("I/O error", errno=e.errno, error=e.strerror)
-        return False
-
-    # FIXME: Exceptions for hexlify need to be covered
-
-    data = {"appointment": appointment, "signature": signature, "public_key": hex_pk_der.decode("utf-8")}
-
-    appointment_json = json.dumps(data, sort_keys=True, separators=(",", ":"))
 
+# Sends appointment data to add_appointment endpoint to be processed by the server.
+def post_data_to_add_appointment_endpoint(add_appointment_endpoint, appointment_json):
     logger.info("Sending appointment to PISA")
 
     try:
@@ -176,15 +203,15 @@ def add_appointment(args):
 
     except json.JSONDecodeError:
         logger.error("The response was not valid JSON")
-        return False
+        return None
 
     except ConnectTimeout:
         logger.error("Can't connect to pisa API. Connection timeout")
-        return False
+        return None
 
     except ConnectionError:
         logger.error("Can't connect to pisa API. Server cannot be reached")
-        return False
+        return None
 
     if r.status_code != HTTP_OK:
         if "error" not in response_json:
@@ -196,14 +223,17 @@ def add_appointment(args):
                 status_code=r.status_code,
                 description=error,
             )
-        return False
+        return None
 
     if "signature" not in response_json:
         logger.error("The response does not contain the signature of the appointment")
-        return False
+        return None
 
-    signature = response_json["signature"]
-    # verify that the returned signature is valid
+    return response_json
+
+
+# Verify that the signature returned from the watchtower is valid.
+def check_signature(signature, appointment):
     try:
         pisa_pk_der = load_key_file_data(PISA_PUBLIC_KEY)
         pisa_pk = Cryptographer.load_public_key_der(pisa_pk_der)
@@ -212,7 +242,7 @@ def add_appointment(args):
             logger.error("Failed to deserialize the public key. It might be in an unsupported format")
             return False
 
-        is_sig_valid = Cryptographer.verify(appointment.serialize(), signature, pisa_pk)
+        return Cryptographer.verify(appointment.serialize(), signature, pisa_pk)
 
     except FileNotFoundError:
         logger.error("Pisa's public key file not found. Please check your settings")
@@ -222,21 +252,6 @@ def add_appointment(args):
         logger.error("I/O error", errno=e.errno, error=e.strerror)
         return False
 
-    if not is_sig_valid:
-        logger.error("The returned appointment's signature is invalid")
-        return False
-
-    logger.info("Appointment accepted and signed by Pisa")
-    # all good, store appointment and signature
-    try:
-        save_signed_appointment(appointment, signature)
-
-    except OSError as e:
-        logger.error("There was an error while saving the appointment", error=e)
-        return False
-
-    return True
-
 
 def get_appointment(args):
     if not args:
@@ -260,8 +275,9 @@ def get_appointment(args):
 
     try:
         r = requests.get(url=get_appointment_endpoint + parameters, timeout=5)
+        logger.info("Appointment response returned from server: " + str(r))
+        return True
 
-        print(json.dumps(r.json(), indent=4, sort_keys=True))
     except ConnectTimeout:
         logger.error("Can't connect to pisa API. Connection timeout")
         return False
@@ -270,7 +286,47 @@ def get_appointment(args):
         logger.error("Can't connect to pisa API. Server cannot be reached")
         return False
 
-    return True
+
+def get_appointment_signature(appointment):
+    try:
+        sk_der = load_key_file_data(CLI_PRIVATE_KEY)
+        cli_sk = Cryptographer.load_private_key_der(sk_der)
+
+        signature = Cryptographer.sign(appointment.serialize(), cli_sk)
+
+        return signature
+
+    except ValueError:
+        logger.error("Failed to deserialize the public key. It might be in an unsupported format")
+        return False
+
+    except FileNotFoundError:
+        logger.error("Client's private key file not found. Please check your settings")
+        return False
+
+    except IOError as e:
+        logger.error("I/O error", errno=e.errno, error=e.strerror)
+        return False
+
+
+def get_pk():
+    try:
+        cli_pk_der = load_key_file_data(CLI_PUBLIC_KEY)
+        hex_pk_der = binascii.hexlify(cli_pk_der)
+
+        return hex_pk_der
+
+    except FileNotFoundError:
+        logger.error("Client's public key file not found. Please check your settings")
+        return False
+
+    except IOError as e:
+        logger.error("I/O error", errno=e.errno, error=e.strerror)
+        return False
+
+    except binascii.Error as e:
+        logger.error("Could not successfully encode public key as hex: ", e)
+        return False
 
 
 def show_usage():
diff --git a/common/tools.py b/common/tools.py
index e527e33..2ac6d1e 100644
--- a/common/tools.py
+++ b/common/tools.py
@@ -1,4 +1,5 @@
 import re
+from common.constants import LOCATOR_LEN_HEX
 
 
 def check_sha256_hex_format(value):
@@ -12,3 +13,15 @@ def check_sha256_hex_format(value):
         :mod:`bool`: Whether or not the value matches the format.
     """
     return isinstance(value, str) and re.match(r"^[0-9A-Fa-f]{64}$", value) is not None
+
+
+def compute_locator(tx_id):
+    """
+    Computes an appointment locator given a transaction id.
+    Args:
+        tx_id (:obj:`str`): the transaction id used to compute the locator.
+    Returns:
+       (:obj:`str`): The computed locator.
+    """
+
+    return tx_id[:LOCATOR_LEN_HEX]
diff --git a/pisa/watcher.py b/pisa/watcher.py
index 9d659db..3d46032 100644
--- a/pisa/watcher.py
+++ b/pisa/watcher.py
@@ -3,7 +3,7 @@ from queue import Queue
 from threading import Thread
 
 from common.cryptographer import Cryptographer
-from common.constants import LOCATOR_LEN_HEX
+from common.tools import compute_locator
 
 from common.logger import Logger
 from pisa.cleaner import Cleaner
@@ -71,20 +71,6 @@ class Watcher:
         if not isinstance(responder, Responder):
             self.responder = Responder(db_manager)
 
-    @staticmethod
-    def compute_locator(tx_id):
-        """
-        Computes an appointment locator given a transaction id.
-
-        Args:
-            tx_id (:obj:`str`): the transaction id used to compute the locator.
-
-        Returns:
-           (:obj:`str`): The computed locator.
-        """
-
-        return tx_id[:LOCATOR_LEN_HEX]
-
     def add_appointment(self, appointment):
         """
         Adds a new appointment to the ``appointments`` dictionary if ``max_appointments`` has not been reached.
@@ -238,7 +224,7 @@ class Watcher:
             found.
         """
 
-        potential_locators = {Watcher.compute_locator(txid): txid for txid in txids}
+        potential_locators = {compute_locator(txid): txid for txid in txids}
 
         # Check is any of the tx_ids in the received block is an actual match
         intersection = set(self.locator_uuid_map.keys()).intersection(potential_locators.keys())
diff --git a/test/pisa/unit/conftest.py b/test/pisa/unit/conftest.py
index 4ff9028..cc215c5 100644
--- a/test/pisa/unit/conftest.py
+++ b/test/pisa/unit/conftest.py
@@ -16,6 +16,7 @@ from pisa.watcher import Watcher
 from pisa.tools import bitcoin_cli
 from pisa.db_manager import DBManager
 from common.appointment import Appointment
+from common.tools import compute_locator
 
 from bitcoind_mock.utils import sha256d
 from bitcoind_mock.transaction import TX
@@ -103,7 +104,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"))
diff --git a/test/pisa/unit/test_watcher.py b/test/pisa/unit/test_watcher.py
index 8ec331c..4fa2252 100644
--- a/test/pisa/unit/test_watcher.py
+++ b/test/pisa/unit/test_watcher.py
@@ -16,7 +16,7 @@ from test.pisa.unit.conftest import (
 )
 from pisa.conf import EXPIRY_DELTA, MAX_APPOINTMENTS
 
-from common.tools import check_sha256_hex_format
+from common.tools import check_sha256_hex_format, compute_locator
 from common.cryptographer import Cryptographer
 
 
@@ -46,7 +46,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):
@@ -219,7 +219,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}

From 39208e4b144ba70c519347da698afd619889a021 Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Mon, 23 Dec 2019 16:19:01 -0500
Subject: [PATCH 6/8] Test new functions split off in pisa_cli

---
 test/apps/cli/unit/test_pisa_cli.py | 160 ++++++++++++++++++++++++----
 1 file changed, 142 insertions(+), 18 deletions(-)

diff --git a/test/apps/cli/unit/test_pisa_cli.py b/test/apps/cli/unit/test_pisa_cli.py
index e14fd0b..4f47f98 100644
--- a/test/apps/cli/unit/test_pisa_cli.py
+++ b/test/apps/cli/unit/test_pisa_cli.py
@@ -1,23 +1,41 @@
 import responses
 import json
+import os
+import pytest
 from binascii import hexlify
 
 from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives import hashes, 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
@@ -31,19 +49,49 @@ dummy_appointment_request = {
     "start_time": 1500,
     "end_time": 50000,
     "to_self_delay": 200,
+    "encrypted_blob": get_random_value_hex(120),
 }
-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(None))
+
+
+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 +99,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(None)}
 
     request_url = "http://{}/".format(pisa_endpoint)
     responses.add(responses.POST, request_url, json=response, status=200)
@@ -72,12 +122,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(None),  # Sign with a bad key
     }
 
     request_url = "http://{}/".format(pisa_endpoint)
@@ -86,3 +138,75 @@ def test_add_appointment_with_invalid_signature(monkeypatch):
     result = pisa_cli.add_appointment([json.dumps(dummy_appointment_request)])
 
     assert not result
+
+
+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, funcion 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
+
+
+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)

From 3775b78500f2427fd2e356c8e4a862fc5d395cec Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Thu, 26 Dec 2019 21:54:55 -0500
Subject: [PATCH 7/8] Fix filename typo in cli README

---
 apps/cli/README.md | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/apps/cli/README.md b/apps/cli/README.md
index a7b9393..9002c93 100644
--- a/apps/cli/README.md
+++ b/apps/cli/README.md
@@ -1,6 +1,6 @@
-# pisa-cli
+# pisa_cli
 
-`pisa-cli` is a command line interface to interact with the PISA server, written in Python3.
+`pisa_cli` is a command line interface to interact with the PISA server, written in Python3.
 
 ## Dependencies
 Refer to [DEPENDENCIES.md](DEPENDENCIES.md)
@@ -11,7 +11,7 @@ Refer to [INSTALL.md](INSTALL.md)
 
 ## Usage
 
-	python pisa-cli.py [global options] command [command options] [arguments]
+	python pisa_cli.py [global options] command [command options] [arguments]
 	
 #### Global options
 
@@ -54,7 +54,7 @@ The API will return a `text/plain` HTTP response code `200/OK` if the appointmen
 
 #### Usage
 
-	python pisa-cli add_appointment [command options] <appointment>/<path_to_appointment_file>
+	python pisa_cli add_appointment [command options] <appointment>/<path_to_appointment_file>
 	
 if `-f, --file` **is** specified, then the command expects a path to a json file instead of a json encoded
 	string as parameter.
@@ -100,7 +100,7 @@ if `-f, --file` **is** specified, then the command expects a path to a json file
 	
 #### Usage
 
-	python pisa-cli get_appointment <appointment_locator>
+	python pisa_cli get_appointment <appointment_locator>
 	
 
 	
@@ -109,18 +109,18 @@ if `-f, --file` **is** specified, then the command expects a path to a json file
 Shows the list of commands or help about how to run a specific command.
 
 #### Usage
-	python pisa-cli help
+	python pisa_cli help
 	
 or
 
-	python pisa-cli help command
+	python pisa_cli help command
 
 ## Example
 
 1. Generate a new dummy appointment. **Note:** this appointment will never be fulfilled (it will eventually expire) since it does not corresopond to a valid transaction. However it can be used to interact with the PISA API.
 
     ```
-    python pisa-cli.py generate_dummy_appointment
+    python pisa_cli.py generate_dummy_appointment
     ```
 
     That will create a json file that follows the appointment data structure filled with dummy data and store it in   `dummy_appointment_data.json`.
@@ -128,7 +128,7 @@ or
 2. Send the appointment to the PISA API. Which will then start monitoring for matching transactions.
 
     ```
-    python pisa-cli.py add_appointment -f dummy_appointment_data.json
+    python pisa_cli.py add_appointment -f dummy_appointment_data.json
     ```
 
     This returns a appointment locator that can be used to get updates about this appointment from PISA.
@@ -136,9 +136,9 @@ or
 3. Test that PISA is still watching the appointment by replacing the appointment locator received into the following command:
 
     ```
-    python pisa-cli.py get_appointment <appointment_locator>
+    python pisa_cli.py get_appointment <appointment_locator>
     ```
 
 ## PISA API	
 
-If you wish to read about the underlying API, and how to write your own tool to interact with it, refer to [PISA-API.md](PISA-API.md)
\ No newline at end of file
+If you wish to read about the underlying API, and how to write your own tool to interact with it, refer to [PISA-API.md](PISA-API.md)

From bd41c8b862e76a3020d7583ea7d8b854cc2d3d90 Mon Sep 17 00:00:00 2001
From: Turtle <orbitalturtle@protonmail.com>
Date: Fri, 27 Dec 2019 01:29:34 -0500
Subject: [PATCH 8/8] Add unit tests for remaining cli functions

---
 test/apps/cli/unit/test_pisa_cli.py | 80 ++++++++++++++++++++++++++---
 1 file changed, 72 insertions(+), 8 deletions(-)

diff --git a/test/apps/cli/unit/test_pisa_cli.py b/test/apps/cli/unit/test_pisa_cli.py
index 4f47f98..74c6a95 100644
--- a/test/apps/cli/unit/test_pisa_cli.py
+++ b/test/apps/cli/unit/test_pisa_cli.py
@@ -1,11 +1,11 @@
 import responses
 import json
 import os
-import pytest
+import shutil
 from binascii import hexlify
 
 from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import ec
 
 from common.appointment import Appointment
@@ -49,7 +49,6 @@ dummy_appointment_request = {
     "start_time": 1500,
     "end_time": 50000,
     "to_self_delay": 200,
-    "encrypted_blob": get_random_value_hex(120),
 }
 
 # This is the format appointment turns into once it hits "add_appointment"
@@ -73,7 +72,7 @@ def get_dummy_pisa_pk_der(*args):
 
 
 def get_dummy_hex_pk_der(*args):
-    return hexlify(get_dummy_pisa_pk_der(None))
+    return hexlify(get_dummy_pisa_pk_der())
 
 
 def get_dummy_signature(*args):
@@ -104,7 +103,7 @@ def test_add_appointment(monkeypatch):
     monkeypatch.setattr(pisa_cli, "get_pk", get_dummy_hex_pk_der)
     monkeypatch.setattr(pisa_cli, "check_signature", valid_sig)
 
-    response = {"locator": dummy_appointment.to_dict()["locator"], "signature": get_dummy_signature(None)}
+    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)
@@ -129,7 +128,7 @@ def test_add_appointment_with_invalid_signature(monkeypatch):
 
     response = {
         "locator": dummy_appointment.to_dict()["locator"],
-        "signature": get_bad_signature(None),  # Sign with a bad key
+        "signature": get_bad_signature(),  # Sign with a bad key
     }
 
     request_url = "http://{}/".format(pisa_endpoint)
@@ -137,7 +136,44 @@ 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():
@@ -158,7 +194,7 @@ def test_parse_add_appointment_args():
 
     os.remove("appt_test_file")
 
-    # If appointment json is passed in, funcion should work.
+    # 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
 
@@ -194,6 +230,34 @@ def test_check_signature(monkeypatch):
     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)