Merge ~afreiberger/charm-openstack-service-checks/+git/charm-openstack-service-checks:blacken-20.08 into ~llama-charmers/charm-openstack-service-checks:master

[Drew Freiberger]

[Alvaro Uria (aluria)]

lgtm

review: Approve

diff --git a/src/files/plugins/check_contrail_analytics_alarms.py b/src/files/plugins/check_contrail_analytics_alarms.py
index 0b4d3be..aa12a3e 100755
--- a/src/files/plugins/check_contrail_analytics_alarms.py
+++ b/src/files/plugins/check_contrail_analytics_alarms.py
@@ -12,8 +12,8 @@ import subprocess
 
 import nagios_plugin3
 
-DEFAULT_IGNORED = r''
-Alarm = collections.namedtuple('Alarm', 'ts, desc')
+DEFAULT_IGNORED = r""
+Alarm = collections.namedtuple("Alarm", "ts, desc")
 
 
 def parse_contrail_alarms(data, ignored=DEFAULT_IGNORED):
@@ -37,37 +37,31 @@ def parse_contrail_alarms(data, ignored=DEFAULT_IGNORED):
             for alarm in item["value"]["UVEAlarms"]["alarms"]:
                 ack = alarm["ack"]
                 alarm_info = {
-                    'hostname': hostname,
-                    'nagios_status': 'WARNING',
-                    'desc': alarm["description"],
-                    'sev': alarm["severity"],
-                    'ts': datetime.datetime.utcfromtimestamp(alarm["timestamp"] / 1e6),
-                    'type': alarm["type"],
+                    "hostname": hostname,
+                    "nagios_status": "WARNING",
+                    "desc": alarm["description"],
+                    "sev": alarm["severity"],
+                    "ts": datetime.datetime.utcfromtimestamp(alarm["timestamp"] / 1e6),
+                    "type": alarm["type"],
                 }
                 if not ack:
-                    alarm_info["nagios_status"] = 'CRITICAL'
+                    alarm_info["nagios_status"] = "CRITICAL"
 
                 alarm_event = (
-                    '{nagios_status}: {node_type}{{{hostname}, sev={sev}, '
-                    'ts[{ts}]}} {desc}'.format(node_type=node_type, **alarm_info)
+                    "{nagios_status}: {node_type}{{{hostname}, sev={sev}, "
+                    "ts[{ts}]}} {desc}".format(node_type=node_type, **alarm_info)
                 )
                 msgs[alarm["timestamp"]].append(alarm_event)
 
     # msgs is a dict keyed on integer timestamp
     # whose values are lists of strings representing the alerts
     search_re = re.compile(ignored)
-    full = [
-        Alarm(ts, alert)
-        for ts, alerts in msgs.items()
-        for alert in alerts
-    ]
-    ignoring = list(
-        filter(lambda m: search_re.search(m.desc), full)
-    ) if ignored else []
+    full = [Alarm(ts, alert) for ts, alerts in msgs.items() for alert in alerts]
+    ignoring = list(filter(lambda m: search_re.search(m.desc), full)) if ignored else []
     important = set(full) - set(ignoring)
 
-    total_crit_count = len([a for a in full if a.desc.startswith('CRITICAL')])
-    important_crit = len([a for a in important if a.desc.startswith('CRITICAL')])
+    total_crit_count = len([a for a in full if a.desc.startswith("CRITICAL")])
+    important_crit = len([a for a in important if a.desc.startswith("CRITICAL")])
     important_count = len(important)
     if important_crit > 0:
         msg = "CRITICAL: "
@@ -77,10 +71,9 @@ def parse_contrail_alarms(data, ignored=DEFAULT_IGNORED):
         msg = "OK: "
     msg += (
         "total_alarms[{}], unacked_or_sev_gt_0[{}], total_ignored[{}], "
-        "ignoring r'{}'\n"
-        .format(len(full), total_crit_count, len(ignoring), ignored)
+        "ignoring r'{}'\n".format(len(full), total_crit_count, len(ignoring), ignored)
     )
-    msg += '\n'.join(_.desc for _ in sorted(important))
+    msg += "\n".join(_.desc for _ in sorted(important))
     return msg
 
 
@@ -93,35 +86,37 @@ def check_contrail_alarms(contrail_vip, token, **kwargs):
 
     :returns: None
     """
-    url = 'http://{}:8081/analytics/alarms'.format(contrail_vip)
-    headers = {'X-Auth-Token': token}
+    url = "http://{}:8081/analytics/alarms".format(contrail_vip)
+    headers = {"X-Auth-Token": token}
     try:
         r = requests.get(url=url, headers=headers)
     except requests.exceptions.ConnectionError as error:
         raise nagios_plugin3.CriticalError(
-            'CRITICAL: contrail analytics API error: {}'.format(error))
+            "CRITICAL: contrail analytics API error: {}".format(error)
+        )
 
     if r.status_code != 200:
         raise nagios_plugin3.CriticalError(
-            'CRITICAL: contrail analytics API return code is {}'.format(r.status_code))
+            "CRITICAL: contrail analytics API return code is {}".format(r.status_code)
+        )
 
     result = r.json()
     msg = parse_contrail_alarms(result, **kwargs)
 
-    if msg.startswith('CRITICAL: '):
+    if msg.startswith("CRITICAL: "):
         raise nagios_plugin3.CriticalError(msg)
-    elif msg.startswith('WARNING: '):
+    elif msg.startswith("WARNING: "):
         raise nagios_plugin3.WarnError(msg)
     print(msg)
 
 
 def load_os_envvars(args):
     # grab environment vars
-    command = ['/bin/bash', '-c', "source {} && env".format(args.env)]
+    command = ["/bin/bash", "-c", "source {} && env".format(args.env)]
     proc = subprocess.Popen(command, stdout=subprocess.PIPE)
     for line in proc.stdout:
-        (key, _, value) = line.partition(b'=')
-        os.environ[key.decode('utf-8')] = value.rstrip().decode('utf-8')
+        (key, _, value) = line.partition(b"=")
+        os.environ[key.decode("utf-8")] = value.rstrip().decode("utf-8")
     proc.communicate()
 
 
@@ -130,19 +125,28 @@ def validate_ipv4(ipv4_addr):
         ipaddress.IPv4Address(ipv4_addr)
     except ipaddress.AddressValueError:
         raise nagios_plugin3.UnknownError(
-            'UNKNOWN: invalid contrail IPv4 address {}'.format(ipv4_addr))
+            "UNKNOWN: invalid contrail IPv4 address {}".format(ipv4_addr)
+        )
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Check Contrail alarms')
-    parser.add_argument('--env', dest='env',
-                        default='/var/lib/nagios/nagios.novarc',
-                        help='Novarc file to use for this check')
-    parser.add_argument('--host', '-H', dest='host', nargs=1,
-                        help='Contrail Analytics Virtual IP')
-    parser.add_argument('--ignored', dest="ignored", type=str,
-                        default=DEFAULT_IGNORED,
-                        help='Comma separated list of alerts to ignore')
+    parser = argparse.ArgumentParser(description="Check Contrail alarms")
+    parser.add_argument(
+        "--env",
+        dest="env",
+        default="/var/lib/nagios/nagios.novarc",
+        help="Novarc file to use for this check",
+    )
+    parser.add_argument(
+        "--host", "-H", dest="host", nargs=1, help="Contrail Analytics Virtual IP"
+    )
+    parser.add_argument(
+        "--ignored",
+        dest="ignored",
+        type=str,
+        default=DEFAULT_IGNORED,
+        help="Comma separated list of alerts to ignore",
+    )
     args = parser.parse_args()
 
     # Validate Contrail Analytics IP
@@ -153,19 +157,17 @@ def main():
 
     # parse ignored list
     unique = sorted(set(args.ignored.split(",")))
-    ignored_re = r'|'.join('(?:{})'.format(_) for _ in unique)
+    ignored_re = r"|".join("(?:{})".format(_) for _ in unique)
 
     # Retrieve token from Keystone
     load_os_envvars(args)
-    keystone_client = os_client_config.session_client('identity', cloud='envvars')
+    keystone_client = os_client_config.session_client("identity", cloud="envvars")
     token = keystone_client.get_token()
 
     nagios_plugin3.try_check(
-        check_contrail_alarms,
-        contrail_analytics_vip, token,
-        ignored=ignored_re
+        check_contrail_alarms, contrail_analytics_vip, token, ignored=ignored_re
     )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/files/plugins/check_nova_services.py b/src/files/plugins/check_nova_services.py
index 4ee6420..5da5955 100755
--- a/src/files/plugins/check_nova_services.py
+++ b/src/files/plugins/check_nova_services.py
@@ -15,107 +15,130 @@ def check_hosts_up(args, aggregate, hosts, services_compute):
     # out: dict, msg_text, status
     status_crit = False
     status_warn = False
-    counts = {'down': 0, 'disabled': 0, 'ok': 0}
+    counts = {"down": 0, "disabled": 0, "ok": 0}
     local_msg = []
     for host in hosts:
-        host_svc = next(svc for svc in services_compute if svc['host'] == host)
-        if host_svc['status'] == 'enabled':
-            if host_svc['state'] == 'up':
+        host_svc = next(svc for svc in services_compute if svc["host"] == host)
+        if host_svc["status"] == "enabled":
+            if host_svc["state"] == "up":
                 # enabled and up, increment the counter
-                counts['ok'] += 1
+                counts["ok"] += 1
             else:
                 # enabled and down
-                counts['down'] += 1
-                local_msg.append('{} down'.format(host))
+                counts["down"] += 1
+                local_msg.append("{} down".format(host))
         else:
-            counts['disabled'] += 1
-            local_msg.append('Host {} disabled'.format(host))
+            counts["disabled"] += 1
+            local_msg.append("Host {} disabled".format(host))
     # check the counts
-    if counts['down'] > 0:
+    if counts["down"] > 0:
         status_crit = True
-    if counts['disabled'] > 0 and not args.skip_disabled:
+    if counts["disabled"] > 0 and not args.skip_disabled:
         status_warn = True
-    if counts['ok'] <= args.warn:
+    if counts["ok"] <= args.warn:
         status_warn = True
-        if counts['ok'] <= args.crit:
+        if counts["ok"] <= args.crit:
             status_crit = True
-        local_msg.append('Host Aggregate {} has {} hosts alive'.format(
-            aggregate, counts['ok']))
+        local_msg.append(
+            "Host Aggregate {} has {} hosts alive".format(aggregate, counts["ok"])
+        )
     nova_status = {
-        'agg_name': aggregate,
-        'msg_text': ', '.join(local_msg),
-        'critical': status_crit,
-        'warning': status_warn,
+        "agg_name": aggregate,
+        "msg_text": ", ".join(local_msg),
+        "critical": status_crit,
+        "warning": status_warn,
     }
     return nova_status
 
 
 def check_nova_services(args, nova):
-    aggregates = nova.get('/os-aggregates').json()['aggregates']
-    services = nova.get('/os-services').json()['services']
-    services_compute = [x for x in services if x['binary'] == 'nova-compute']
-    msg = ['nova-compute']
+    aggregates = nova.get("/os-aggregates").json()["aggregates"]
+    services = nova.get("/os-services").json()["services"]
+    services_compute = [x for x in services if x["binary"] == "nova-compute"]
+    msg = ["nova-compute"]
     status = []
     hosts_checked = []
     for agg in aggregates:
         # skip the defined host aggregates to be skipped from the config
         # making it case-insensitive
-        skipped_aggregates = [name.lower() for name in args.skip_aggregates.split(',')]
-        aggregate_name = agg['name'].lower()
+        skipped_aggregates = [name.lower() for name in args.skip_aggregates.split(",")]
+        aggregate_name = agg["name"].lower()
         if aggregate_name in skipped_aggregates:
             continue
         # get a list of hosts, pass to the function
-        hosts = agg['hosts']
+        hosts = agg["hosts"]
         hosts_checked.append(hosts)
-        status.append(check_hosts_up(args, agg['name'], hosts,
-                                     services_compute))
+        status.append(check_hosts_up(args, agg["name"], hosts, services_compute))
     # find hosts that haven't been checked already
     hosts_checked = [item for sublist in hosts_checked for item in sublist]
-    hosts_not_checked = [x['host'] for x in services_compute
-                         if x['host'] not in hosts_checked]
+    hosts_not_checked = [
+        x["host"] for x in services_compute if x["host"] not in hosts_checked
+    ]
     if len(hosts_not_checked) > 0:
-        status.append(check_hosts_up(args, '(not-part-of-any-agg)', hosts_not_checked,
-                                     services_compute))
-    status_crit = len([agg['critical'] for agg in status
-                       if agg['critical']])
-    status_warn = len([agg['warning'] for agg in status
-                       if agg['warning']])
-    msg.extend([x['msg_text'] for x in status if x['msg_text'] != ''])
+        status.append(
+            check_hosts_up(
+                args, "(not-part-of-any-agg)", hosts_not_checked, services_compute
+            )
+        )
+    status_crit = len([agg["critical"] for agg in status if agg["critical"]])
+    status_warn = len([agg["warning"] for agg in status if agg["warning"]])
+    msg.extend([x["msg_text"] for x in status if x["msg_text"] != ""])
     if status_crit:
-        output = 'CRITICAL: {}'.format(', '.join(msg))
+        output = "CRITICAL: {}".format(", ".join(msg))
         raise nagios_plugin3.CriticalError(output)
     if status_warn:
-        output = 'WARNING: {}'.format(', '.join(msg))
+        output = "WARNING: {}".format(", ".join(msg))
         raise nagios_plugin3.WarnError(output)
-    print('OK: Nova-compute services happy')
+    print("OK: Nova-compute services happy")
 
 
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Check Nova-compute status')
-    parser.add_argument('--warn', dest='warn', type=int, default=2,
-                        help='Warn at this many hosts running')
-    parser.add_argument('--crit', dest='crit', type=int, default=1,
-                        help='Critical at this many hosts running or less')
-    parser.add_argument('--skip-aggregates', dest='skip_aggregates', type=str,
-                        default='', nargs='?',
-                        help='Comma separated list of types of aggregates to skip.')
-    parser.add_argument('--env', dest='env',
-                        default='/var/lib/nagios/nagios.novarc',
-                        help='Novarc file to use for this check')
-    parser.add_argument('--skip-disabled', dest='skip_disabled',
-                        help='Pass this flag not to alert on any disabled nova-compute services',
-                        action='store_true')
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Check Nova-compute status")
+    parser.add_argument(
+        "--warn",
+        dest="warn",
+        type=int,
+        default=2,
+        help="Warn at this many hosts running",
+    )
+    parser.add_argument(
+        "--crit",
+        dest="crit",
+        type=int,
+        default=1,
+        help="Critical at this many hosts running or less",
+    )
+    parser.add_argument(
+        "--skip-aggregates",
+        dest="skip_aggregates",
+        type=str,
+        default="",
+        nargs="?",
+        help="Comma separated list of types of aggregates to skip.",
+    )
+    parser.add_argument(
+        "--env",
+        dest="env",
+        default="/var/lib/nagios/nagios.novarc",
+        help="Novarc file to use for this check",
+    )
+    parser.add_argument(
+        "--skip-disabled",
+        dest="skip_disabled",
+        help="Pass this flag not to alert on any disabled nova-compute services",
+        action="store_true",
+    )
     args = parser.parse_args()
     # No arg was passed to --skip-aggregates (juju config is empty)
     if args.skip_aggregates is None:
-        args.skip_aggregates = ''
+        args.skip_aggregates = ""
 
     # grab environment vars
-    command = ['/bin/bash', '-c', 'source {} && env'.format(args.env)]
+    command = ["/bin/bash", "-c", "source {} && env".format(args.env)]
     proc = subprocess.Popen(command, stdout=subprocess.PIPE)
     for line in proc.stdout:
-        (key, _, value) = line.partition(b'=')
-        os.environ[key.decode('utf-8')] = value.rstrip().decode('utf-8')
+        (key, _, value) = line.partition(b"=")
+        os.environ[key.decode("utf-8")] = value.rstrip().decode("utf-8")
     proc.communicate()
-    nova = os_client_config.session_client('compute', cloud='envvars')
+    nova = os_client_config.session_client("compute", cloud="envvars")
     nagios_plugin3.try_check(check_nova_services, args, nova)
diff --git a/src/files/plugins/check_octavia.py b/src/files/plugins/check_octavia.py
index bb6debc..c7e4d02 100755
--- a/src/files/plugins/check_octavia.py
+++ b/src/files/plugins/check_octavia.py
@@ -12,18 +12,18 @@ import sys
 import openstack
 
 
-Alarm = collections.namedtuple('Alarm', 'lvl, desc')
-DEFAULT_IGNORED = r''
+Alarm = collections.namedtuple("Alarm", "lvl, desc")
+DEFAULT_IGNORED = r""
 NAGIOS_STATUS_OK = 0
 NAGIOS_STATUS_WARNING = 1
 NAGIOS_STATUS_CRITICAL = 2
 NAGIOS_STATUS_UNKNOWN = 3
 
 NAGIOS_STATUS = {
-    NAGIOS_STATUS_OK: 'OK',
-    NAGIOS_STATUS_WARNING: 'WARNING',
-    NAGIOS_STATUS_CRITICAL: 'CRITICAL',
-    NAGIOS_STATUS_UNKNOWN: 'UNKNOWN',
+    NAGIOS_STATUS_OK: "OK",
+    NAGIOS_STATUS_WARNING: "WARNING",
+    NAGIOS_STATUS_CRITICAL: "CRITICAL",
+    NAGIOS_STATUS_UNKNOWN: "UNKNOWN",
 }
 
 
@@ -52,22 +52,21 @@ def filter_checks(alarms, ignored=DEFAULT_IGNORED):
         status = NAGIOS_STATUS_OK
     msg = (
         "total_alarms[{}], total_crit[{}], total_ignored[{}], "
-        "ignoring r'{}'\n"
-        .format(len(full), total_crit, len(ignoring), ignored)
+        "ignoring r'{}'\n".format(len(full), total_crit, len(ignoring), ignored)
     )
-    msg += '\n'.join(_.desc for _ in sorted(important))
+    msg += "\n".join(_.desc for _ in sorted(important))
     return status, msg
 
 
 def nagios_exit(args, results):
     # parse ignored list
     unique = sorted(filter(None, set(args.ignored.split(","))))
-    ignored_re = r'|'.join('(?:{})'.format(_) for _ in unique)
+    ignored_re = r"|".join("(?:{})".format(_) for _ in unique)
 
     status, message = filter_checks(results, ignored=ignored_re)
     assert status in NAGIOS_STATUS, "Invalid Nagios status code"
     # prefix status name to message
-    output = '{}: {}'.format(NAGIOS_STATUS[status], message)
+    output = "{}: {}".format(NAGIOS_STATUS[status], message)
     return status, output
 
 
@@ -81,18 +80,26 @@ def check_loadbalancers(connection):
     lb_enabled = [lb for lb in lb_all if lb.is_admin_state_up]
 
     # check provisioning_status is ACTIVE for each lb
-    bad_lbs = [(
-        NAGIOS_STATUS_CRITICAL,
-        'loadbalancer {} provisioning_status is {}'.format(
-            lb.id, lb.provisioning_status)
-        ) for lb in lb_enabled if lb.provisioning_status != 'ACTIVE']
+    bad_lbs = [
+        (
+            NAGIOS_STATUS_CRITICAL,
+            "loadbalancer {} provisioning_status is {}".format(
+                lb.id, lb.provisioning_status
+            ),
+        )
+        for lb in lb_enabled
+        if lb.provisioning_status != "ACTIVE"
+    ]
 
     # raise WARNING if operating_status is not ONLINE
-    bad_lbs += [(
-        NAGIOS_STATUS_CRITICAL,
-        'loadbalancer {} operating_status is {}'.format(
-            lb.id, lb.operating_status)
-        ) for lb in lb_enabled if lb.operating_status != 'ONLINE']
+    bad_lbs += [
+        (
+            NAGIOS_STATUS_CRITICAL,
+            "loadbalancer {} operating_status is {}".format(lb.id, lb.operating_status),
+        )
+        for lb in lb_enabled
+        if lb.operating_status != "ONLINE"
+    ]
 
     # check vip port exists for each lb
     net_mgr = connection.network
@@ -102,17 +109,20 @@ def check_loadbalancers(connection):
             net_mgr.get_port(lb.vip_port_id)
         except openstack.exceptions.NotFoundException:
             vip_lbs.append(lb)
-    bad_lbs += [(
-        NAGIOS_STATUS_CRITICAL,
-        'vip port {} for loadbalancer {} not found'.format(
-            lb.vip_port_id, lb.id)
-        ) for lb in vip_lbs]
+    bad_lbs += [
+        (
+            NAGIOS_STATUS_CRITICAL,
+            "vip port {} for loadbalancer {} not found".format(lb.vip_port_id, lb.id),
+        )
+        for lb in vip_lbs
+    ]
 
     # warn about disabled lbs if no other error found
-    bad_lbs += [(
-        NAGIOS_STATUS_WARNING,
-        'loadbalancer {} admin_state_up is False'.format(lb.id)
-        ) for lb in lb_all if not lb.is_admin_state_up]
+    bad_lbs += [
+        (NAGIOS_STATUS_WARNING, "loadbalancer {} admin_state_up is False".format(lb.id))
+        for lb in lb_all
+        if not lb.is_admin_state_up
+    ]
 
     return bad_lbs
 
@@ -126,25 +136,36 @@ def check_pools(connection):
     pools_enabled = [pool for pool in pools_all if pool.is_admin_state_up]
 
     # check provisioning_status is ACTIVE for each pool
-    bad_pools = [(
-        NAGIOS_STATUS_CRITICAL,
-        'pool {} provisioning_status is {}'.format(
-            pool.id, pool.provisioning_status)
-        ) for pool in pools_enabled if pool.provisioning_status != 'ACTIVE']
+    bad_pools = [
+        (
+            NAGIOS_STATUS_CRITICAL,
+            "pool {} provisioning_status is {}".format(
+                pool.id, pool.provisioning_status
+            ),
+        )
+        for pool in pools_enabled
+        if pool.provisioning_status != "ACTIVE"
+    ]
 
     # raise CRITICAL if operating_status is ERROR
-    bad_pools += [(
-        NAGIOS_STATUS_CRITICAL,
-        'pool {} operating_status is {}'.format(
-            pool.id, pool.operating_status)
-        ) for pool in pools_enabled if pool.operating_status == 'ERROR']
+    bad_pools += [
+        (
+            NAGIOS_STATUS_CRITICAL,
+            "pool {} operating_status is {}".format(pool.id, pool.operating_status),
+        )
+        for pool in pools_enabled
+        if pool.operating_status == "ERROR"
+    ]
 
     # raise WARNING if operating_status is NO_MONITOR
-    bad_pools += [(
-        NAGIOS_STATUS_WARNING,
-        'pool {} operating_status is {}'.format(
-            pool.id, pool.operating_status)
-        ) for pool in pools_enabled if pool.operating_status == 'NO_MONITOR']
+    bad_pools += [
+        (
+            NAGIOS_STATUS_WARNING,
+            "pool {} operating_status is {}".format(pool.id, pool.operating_status),
+        )
+        for pool in pools_enabled
+        if pool.operating_status == "NO_MONITOR"
+    ]
 
     return bad_pools
 
@@ -154,29 +175,36 @@ def check_amphorae(connection):
 
     lb_mgr = connection.load_balancer
 
-    resp = lb_mgr.get('/v2/octavia/amphorae')
+    resp = lb_mgr.get("/v2/octavia/amphorae")
     # python api is not available yet, use url
     if resp.status_code != 200:
-        return [(NAGIOS_STATUS_WARNING, 'amphorae api not working')]
+        return [(NAGIOS_STATUS_WARNING, "amphorae api not working")]
 
     data = json.loads(resp.content)
     # ouput is like {"amphorae": [{...}, {...}, ...]}
-    items = data.get('amphorae', [])
+    items = data.get("amphorae", [])
 
     # raise CRITICAL for ERROR status
-    bad_status_list = ('ERROR',)
-    bad_amp = [(
-        NAGIOS_STATUS_CRITICAL,
-        'amphora {} status is {}'.format(item['id'], item['status'])
-        ) for item in items if item['status'] in bad_status_list]
+    bad_status_list = ["ERROR"]
+    bad_amp = [
+        (
+            NAGIOS_STATUS_CRITICAL,
+            "amphora {} status is {}".format(item["id"], item["status"]),
+        )
+        for item in items
+        if item["status"] in bad_status_list
+    ]
 
     # raise WARNING for these status
-    bad_status_list = (
-        'PENDING_CREATE', 'PENDING_UPDATE', 'PENDING_DELETE', 'BOOTING')
-    bad_amp += [(
-        NAGIOS_STATUS_WARNING,
-        'amphora {} status is {}'.format(item['id'], item['status'])
-        ) for item in items if item['status'] in bad_status_list]
+    bad_status_list = ("PENDING_CREATE", "PENDING_UPDATE", "PENDING_DELETE", "BOOTING")
+    bad_amp += [
+        (
+            NAGIOS_STATUS_WARNING,
+            "amphora {} status is {}".format(item["id"], item["status"]),
+        )
+        for item in items
+        if item["status"] in bad_status_list
+    ]
 
     return bad_amp
 
@@ -186,15 +214,18 @@ def check_image(connection, tag, days):
     images = list(img_mgr.images(tag=tag))
 
     if not images:
-        message = ('Octavia requires image with tag {} to create amphora, '
-                   'but none exist').format(tag)
+        message = (
+            "Octavia requires image with tag {} to create amphora, but none exist"
+        ).format(tag)
         return [(NAGIOS_STATUS_CRITICAL, message)]
 
-    active_images = [image for image in images if image.status == 'active']
+    active_images = [image for image in images if image.status == "active"]
     if not active_images:
-        details = ['{}({})'.format(image.name, image.id) for image in images]
-        message = ('Octavia requires image with tag {} to create amphora, '
-                   'but none are active: {}').format(tag, ', '.join(details))
+        details = ["{}({})".format(image.name, image.id) for image in images]
+        message = (
+            "Octavia requires image with tag {} to create amphora, "
+            "but none are active: {}"
+        ).format(tag, ", ".join(details))
         return [(NAGIOS_STATUS_CRITICAL, message)]
 
     # raise WARNING if image is too old
@@ -202,10 +233,12 @@ def check_image(connection, tag, days):
     # updated_at str format: '2019-12-05T18:21:25Z'
     fresh_images = [image for image in active_images if image.updated_at > when]
     if not fresh_images:
-        details = ['{}({})'.format(image.name, image.id) for image in images]
-        message = ('Octavia requires image with tag {} to create amphora, '
-                   'but all images are older than {} day(s): {}'
-                   '').format(tag, days, ', '.join(details))
+        details = ["{}({})".format(image.name, image.id) for image in images]
+        message = (
+            "Octavia requires image with tag {} to create amphora, "
+            "but all images are older than {} day(s): {}"
+            ""
+        ).format(tag, days, ", ".join(details))
         return [(NAGIOS_STATUS_WARNING, message)]
 
     return []
@@ -218,52 +251,69 @@ def process_checks(args):
         return check_image(_connection, args.amp_image_tag, args.amp_image_days)
 
     checks = {
-        'loadbalancers': check_loadbalancers,
-        'amphorae': check_amphorae,
-        'pools': check_pools,
-        'image': _check_image,
+        "loadbalancers": check_loadbalancers,
+        "amphorae": check_amphorae,
+        "pools": check_pools,
+        "image": _check_image,
     }
 
-    connection = openstack.connect(cloud='envvars')
+    connection = openstack.connect(cloud="envvars")
     return nagios_exit(args, checks[args.check](connection))
 
 
 def main():
     parser = argparse.ArgumentParser(
-        description='Check Octavia status',
+        description="Check Octavia status",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
     parser.add_argument(
-        '--env', dest='env', default='/var/lib/nagios/nagios.novarc',
-        help='Novarc file to use for this check')
+        "--env",
+        dest="env",
+        default="/var/lib/nagios/nagios.novarc",
+        help="Novarc file to use for this check",
+    )
 
-    check_choices = ['loadbalancers', 'amphorae', 'pools', 'image']
+    check_choices = ["loadbalancers", "amphorae", "pools", "image"]
     parser.add_argument(
-        '--check', dest='check', metavar='|'.join(check_choices),
-        type=str, choices=check_choices,
+        "--check",
+        dest="check",
+        metavar="|".join(check_choices),
+        type=str,
+        choices=check_choices,
         default=check_choices[0],
-        help='which check to run')
+        help="which check to run",
+    )
 
     parser.add_argument(
-        '--ignored', dest="ignored", type=str,
+        "--ignored",
+        dest="ignored",
+        type=str,
         default=DEFAULT_IGNORED,
-        help='Comma separated list of alerts to ignore')
+        help="Comma separated list of alerts to ignore",
+    )
 
     parser.add_argument(
-        '--amp-image-tag', dest='amp_image_tag', default='octavia-amphora',
-        help='amphora image tag for image check')
+        "--amp-image-tag",
+        dest="amp_image_tag",
+        default="octavia-amphora",
+        help="amphora image tag for image check",
+    )
 
     parser.add_argument(
-        '--amp-image-days', dest='amp_image_days', type=int, default=365,
-        help='raise warning if amphora image is older than these days')
+        "--amp-image-days",
+        dest="amp_image_days",
+        type=int,
+        default=365,
+        help="raise warning if amphora image is older than these days",
+    )
 
     args = parser.parse_args()
     # source environment vars
-    command = ['/bin/bash', '-c', 'source {} && env'.format(args.env)]
+    command = ["/bin/bash", "-c", "source {} && env".format(args.env)]
     proc = subprocess.Popen(command, stdout=subprocess.PIPE)
     for line in proc.stdout:
-        (key, _, value) = line.partition(b'=')
-        os.environ[key.decode('utf-8')] = value.rstrip().decode('utf-8')
+        (key, _, value) = line.partition(b"=")
+        os.environ[key.decode("utf-8")] = value.rstrip().decode("utf-8")
     proc.communicate()
 
     status, message = process_checks(args)
@@ -271,5 +321,5 @@ def main():
     sys.exit(status)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/files/plugins/check_rally.py b/src/files/plugins/check_rally.py
index 62f1a7e..fac835b 100755
--- a/src/files/plugins/check_rally.py
+++ b/src/files/plugins/check_rally.py
@@ -7,49 +7,54 @@ import sys
 import json
 
 # ie. {0} tempest.test.test1 ... success
-TEMPEST_TEST_RE = r'{\d+} [.\w]+ ... (\w+)'
-INPUT_FILE = '/home/nagiososc/rally.status'
+TEMPEST_TEST_RE = r"{\d+} [.\w]+ ... (\w+)"
+INPUT_FILE = "/home/nagiososc/rally.status"
 
 
 def print_results(results):
-    status_message = collections.defaultdict(lambda: 'UNKNOWN')  # 3
-    status_message.update({
-        'success': 'OK',  # 0
-        'fail': 'CRITICAL',  # 2
-        'skip': 'WARNING',  # 1
-    })
-    return_codes = {msg: code
-                    for code, msg in enumerate(['OK', 'WARNING', 'CRITICAL', 'UNKNOWN'])}
-    rc = return_codes['OK']
+    status_message = collections.defaultdict(lambda: "UNKNOWN")  # 3
+    status_message.update(
+        {
+            "success": "OK",  # 0
+            "fail": "CRITICAL",  # 2
+            "skip": "WARNING",  # 1
+        }
+    )
+    return_codes = {
+        msg: code for code, msg in enumerate(["OK", "WARNING", "CRITICAL", "UNKNOWN"])
+    }
+    rc = return_codes["OK"]
     summary = collections.defaultdict(lambda: 0)
 
     output = []
-    for result in sorted(results, key=lambda result: result['message']):
-        if result.get('message', '').startswith('CRITICAL: '):
+    for result in sorted(results, key=lambda result: result["message"]):
+        if result.get("message", "").startswith("CRITICAL: "):
             # Exception caused by run_rally.py, without running 'rally verify'
-            output.append(result['message'])
-            if 'verify' in result['message']:
-                summary['fail'] += 1
+            output.append(result["message"])
+            if "verify" in result["message"]:
+                summary["fail"] += 1
 
             continue
-        elif result.get('message', '').startswith('{'):
+        elif result.get("message", "").startswith("{"):
             # only parse json lines - rest, ignore
-            test_re = re.match(TEMPEST_TEST_RE, result.get('message', ''))
+            test_re = re.match(TEMPEST_TEST_RE, result.get("message", ""))
             if not test_re:
                 continue
 
             test_status = test_re.groups()[0]
-            output.append('{}: {}'.format(status_message[test_status],
-                                          result['message']))
+            output.append(
+                "{}: {}".format(status_message[test_status], result["message"])
+            )
             summary[test_status] += 1
 
     # make the first line carry the worst event out of all the parsed ones
     # ie. all ok except one critical event will return the first line (and return code)
     # as critical
-    nagios_status = 'OK'
-    for status_msg in ['CRITICAL', 'WARNING', 'UNKNOWN', 'OK']:
-        status = [msg for msg in status_message.keys()
-                  if status_message[msg] == status_msg]
+    nagios_status = "OK"
+    for status_msg in ["CRITICAL", "WARNING", "UNKNOWN", "OK"]:
+        status = [
+            msg for msg in status_message.keys() if status_message[msg] == status_msg
+        ]
         if not status or status[0] not in summary:
             continue
 
@@ -60,43 +65,48 @@ def print_results(results):
             break
 
     if len(summary) > 0:
-        print('{}: '.format(nagios_status)
-              + ', '.join(['{}[{}]'.format(status_msg, summary[status_msg])
-                           for status_msg in sorted(summary,
-                                                    key=lambda status: summary[status],
-                                                    reverse=True)
-                           ]))
-    print('\n'.join(output))
+        print(
+            "{}: ".format(nagios_status)
+            + ", ".join(
+                [
+                    "{}[{}]".format(status_msg, summary[status_msg])
+                    for status_msg in sorted(
+                        summary, key=lambda status: summary[status], reverse=True
+                    )
+                ]
+            )
+        )
+    print("\n".join(output))
     return rc
 
 
 def main(results_filename):
     if not os.path.exists(results_filename):
-        print('UNKNOWN: {} does not exist'.format(results_filename))
+        print("UNKNOWN: {} does not exist".format(results_filename))
         return 3
 
     results = []
-    with open(results_filename, 'r') as fd:
+    with open(results_filename, "r") as fd:
         for line in fd.readlines():
             line = line.strip()
             if not line:
                 continue
-            elif len(line) > 5 and line[-5:] == '\x1b[00m':
+            elif len(line) > 5 and line[-5:] == "\x1b[00m":
                 line = line[:-5]
 
-            if not line.startswith('{'):
-                results.append({'message': line})
+            if not line.startswith("{"):
+                results.append({"message": line})
                 continue
 
             try:
                 results.append(json.loads(line))
             except json.decoder.JSONDecodeError as error:
-                print('UNKNOWN: line[{}], error[{}]'.format(line, str(error)))
+                print("UNKNOWN: line[{}], error[{}]".format(line, str(error)))
                 return 3
 
     rc = print_results(results)
     return rc
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(main(INPUT_FILE))
diff --git a/src/files/run_rally.py b/src/files/run_rally.py
index c0e5655..3f0802e 100755
--- a/src/files/run_rally.py
+++ b/src/files/run_rally.py
@@ -8,8 +8,8 @@ import sys
 import shutil
 import tempfile
 
-OUTPUT_FILE = '/home/nagiososc/rally.status'
-HISTORY_FOLDER = '/home/nagiososc/rallystatuses'
+OUTPUT_FILE = "/home/nagiososc/rally.status"
+HISTORY_FOLDER = "/home/nagiososc/rallystatuses"
 
 
 def get_backup_output_filename():
@@ -18,65 +18,83 @@ def get_backup_output_filename():
 
     weekday = datetime.datetime.today().weekday()
     i = 0
-    statusfile = os.path.join(HISTORY_FOLDER, 'rally.status.{}.{}'.format(weekday, i))
+    statusfile = os.path.join(HISTORY_FOLDER, "rally.status.{}.{}".format(weekday, i))
     while os.path.exists(statusfile):
         i += 1
-        statusfile = os.path.join(HISTORY_FOLDER, 'rally.status.{}.{}'.format(weekday, i))
+        statusfile = os.path.join(
+            HISTORY_FOLDER, "rally.status.{}.{}".format(weekday, i)
+        )
 
     return statusfile
 
 
-def _load_envvars(novarc='/var/lib/nagios/nagios.novarc'):
+def _load_envvars(novarc="/var/lib/nagios/nagios.novarc"):
     if not os.path.exists(novarc):
         return False
 
-    output = subprocess.check_output(['/bin/bash', '-c', 'source {} && env'.format(novarc)])
+    output = subprocess.check_output(
+        ["/bin/bash", "-c", "source {} && env".format(novarc)]
+    )
     i = 0
-    for line in output.decode('utf-8').splitlines():
-        key = line.split('=')[0]
-        if not (key.startswith('OS_') or key.count('proxy') > 0 or key.count('PROXY') > 0):
+    for line in output.decode("utf-8").splitlines():
+        key = line.split("=")[0]
+        if not (
+            key.startswith("OS_") or key.count("proxy") > 0 or key.count("PROXY") > 0
+        ):
             continue
-        key, value = line.split('=')
+        key, value = line.split("=")
         os.environ[key] = value
         i += 1
 
-    os.environ['SHELL'] = '/bin/bash'
-    os.environ['HOME'] = '/home/nagiososc'
-    os.environ['PATH'] = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin'
+    os.environ["SHELL"] = "/bin/bash"
+    os.environ["HOME"] = "/home/nagiososc"
+    os.environ[
+        "PATH"
+    ] = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin"
 
     return i >= 3
 
 
-def main(testfile='/home/nagiososc/ostests.txt'):
+def main(testfile="/home/nagiososc/ostests.txt"):
     if not _load_envvars():
-        print('UNKNOWN: could not load OS_ envvars')
+        print("UNKNOWN: could not load OS_ envvars")
         sys.exit(3)
 
     tempoutputfile = tempfile.mktemp()
-    cmd1 = ['fcbtest.rally', 'deployment', 'use', 'snap_generated']
-    cmd2 = ['fcbtest.rally', '--use-json', 'verify', 'start', '--load-list', testfile, '--detailed']
+    cmd1 = ["fcbtest.rally", "deployment", "use", "snap_generated"]
+    cmd2 = [
+        "fcbtest.rally",
+        "--use-json",
+        "verify",
+        "start",
+        "--load-list",
+        testfile,
+        "--detailed",
+    ]
     try:
         subprocess.check_output(cmd1, stderr=subprocess.STDOUT)
         output = subprocess.check_output(cmd2, stderr=subprocess.STDOUT)
-        with open(tempoutputfile, 'w') as fd:
-            fd.write(output.decode('utf-8'))
+        with open(tempoutputfile, "w") as fd:
+            fd.write(output.decode("utf-8"))
         shutil.copy2(tempoutputfile, OUTPUT_FILE)
         shutil.copy2(OUTPUT_FILE, get_backup_output_filename())
         os.unlink(tempoutputfile)
     except subprocess.CalledProcessError as error:
         msg = {
-            'message': 'CRITICAL: fcbtest.rally command failed. {} - {}'.format(str(error), str(error.stdout)),
+            "message": "CRITICAL: fcbtest.rally command failed. {} - {}".format(
+                str(error), str(error.stdout)
+            ),
         }
-        with open(OUTPUT_FILE, 'w') as fd:
-            fd.write('{}\n'.format(json.dumps(msg)))
+        with open(OUTPUT_FILE, "w") as fd:
+            fd.write("{}\n".format(json.dumps(msg)))
 
     except IOError as error:
         msg = {
-            'message': 'CRITICAL: IOError. {}'.format(str(error)),
+            "message": "CRITICAL: IOError. {}".format(str(error)),
         }
-        with open(OUTPUT_FILE, 'a') as fd:
-            fd.write('{}\n'.format(json.dumps(msg)))
+        with open(OUTPUT_FILE, "a") as fd:
+            fd.write("{}\n".format(json.dumps(msg)))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()
diff --git a/src/lib/lib_openstack_service_checks.py b/src/lib/lib_openstack_service_checks.py
index ff4ac9f..405120d 100644
--- a/src/lib/lib_openstack_service_checks.py
+++ b/src/lib/lib_openstack_service_checks.py
@@ -31,215 +31,243 @@ class OSCKeystoneError(Exception):
 class OSCKeystoneServerError(OSCKeystoneError):
     @property
     def workload_status(self):
-        return 'Keystone server error was encountered trying to list keystone '\
-               'resources. Check keystone server health. '\
-               'View juju logs for more info.'
+        return (
+            "Keystone server error was encountered trying to list keystone "
+            "resources. Check keystone server health. "
+            "View juju logs for more info."
+        )
 
 
 class OSCKeystoneClientError(OSCKeystoneError):
     @property
     def workload_status(self):
-        return 'Keystone client request error was encountered trying to '\
-               'keystone resources. Check keystone auth creds and url.'\
-               'View juju logs for more info.'
+        return (
+            "Keystone client request error was encountered trying to "
+            "keystone resources. Check keystone auth creds and url."
+            "View juju logs for more info."
+        )
 
 
 class OSCSslError(OSCKeystoneError):
     @property
     def workload_status(self):
-        return 'SSL error was encountered when requesting Keystone for ' \
-               'resource list.  Check trusted_ssl_ca config option. ' \
-               'View juju logs for more info.'
+        return (
+            "SSL error was encountered when requesting Keystone for "
+            "resource list.  Check trusted_ssl_ca config option. "
+            "View juju logs for more info."
+        )
 
 
-class OSCHelper():
+class OSCHelper:
     def __init__(self):
         self.charm_config = hookenv.config()
         self._keystone_client = None
 
     def store_keystone_credentials(self, creds):
-        '''store keystone credentials'''
+        """store keystone credentials"""
         kv = unitdata.kv()
-        kv.set('keystonecreds', creds)
-        kv.set('rallyinstalled', False)
+        kv.set("keystonecreds", creds)
+        kv.set("rallyinstalled", False)
 
     @property
     def novarc(self):
-        return '/var/lib/nagios/nagios.novarc'
+        return "/var/lib/nagios/nagios.novarc"
 
     @property
     def contrail_analytics_vip(self):
-        return self.charm_config['contrail_analytics_vip']
+        return self.charm_config["contrail_analytics_vip"]
 
     @property
     def contrail_ignored(self):
-        return self.charm_config['contrail_ignored_alarms']
+        return self.charm_config["contrail_ignored_alarms"]
 
     @property
     def plugins_dir(self):
-        return '/usr/local/lib/nagios/plugins/'
+        return "/usr/local/lib/nagios/plugins/"
 
     @property
     def scripts_dir(self):
-        return '/usr/local/bin/'
+        return "/usr/local/bin/"
 
     @property
     def rally_cron_file(self):
-        return '/etc/cron.d/osc_rally'
+        return "/etc/cron.d/osc_rally"
 
     @property
     def is_rally_enabled(self):
-        return self.charm_config['check-rally']
+        return self.charm_config["check-rally"]
 
     @property
     def is_neutron_agents_check_enabled(self):
-        return self.charm_config['check-neutron-agents']
+        return self.charm_config["check-neutron-agents"]
 
     @property
     def is_octavia_check_enabled(self):
-        return self.charm_config['check-octavia']
+        return self.charm_config["check-octavia"]
 
     @property
     def octavia_amp_image_tag(self):
-        return self.charm_config['octavia-amp-image-tag']
+        return self.charm_config["octavia-amp-image-tag"]
 
     @property
     def octavia_amp_image_days(self):
-        return self.charm_config['octavia-amp-image-days']
+        return self.charm_config["octavia-amp-image-days"]
 
     @property
     def skipped_rally_checks(self):
-        skipped_os_components = self.charm_config['skip-rally'].strip()
+        skipped_os_components = self.charm_config["skip-rally"].strip()
         if not skipped_os_components:
             return []
 
         # filter skip-rally input to match available (or supported) components that
         # should be disabled
-        available_os_components = 'cinder glance nova neutron'.split()
-        return [comp.strip().lower() for comp in skipped_os_components.split(',')
-                if comp.strip().lower() in available_os_components]
+        available_os_components = "cinder glance nova neutron".split()
+        return [
+            comp.strip().lower()
+            for comp in skipped_os_components.split(",")
+            if comp.strip().lower() in available_os_components
+        ]
 
     @property
     def rally_cron_schedule(self):
-        schedule = self.charm_config['rally-cron-schedule']
-        if schedule.strip() == '' or len(schedule.strip().split()) != 5:
-            return '*/15 * * * *'
+        schedule = self.charm_config["rally-cron-schedule"]
+        if schedule.strip() == "" or len(schedule.strip().split()) != 5:
+            return "*/15 * * * *"
         else:
             return schedule.strip()
 
     def get_os_credentials(self):
-        ident_creds = config_flags_parser(self.charm_config['os-credentials'])
-        if not ident_creds.get('auth_url'):
-            raise OSCCredentialsError('auth_url')
-        elif '/v3' in ident_creds.get('auth_url'):
-            extra_attrs = ['domain']
-            creds = {'auth_version': 3}
+        ident_creds = config_flags_parser(self.charm_config["os-credentials"])
+        if not ident_creds.get("auth_url"):
+            raise OSCCredentialsError("auth_url")
+        elif "/v3" in ident_creds.get("auth_url"):
+            extra_attrs = ["domain"]
+            creds = {"auth_version": 3}
         else:
             extra_attrs = []
             creds = {}
 
-        common_attrs = ('username password region_name auth_url'
-                        ' credentials_project').split()
+        common_attrs = (
+            "username password region_name auth_url credentials_project"
+        ).split()
         all_attrs = common_attrs + extra_attrs
         missing = [k for k in all_attrs if k not in ident_creds]
         if missing:
-            raise OSCCredentialsError(', '.join(missing))
-
-        ident_creds['auth_url'] = ident_creds['auth_url'].strip('\"\'')
-        creds.update(dict([(k, ident_creds.get(k))
-                           for k in all_attrs
-                           if k not in ('credentials_project', 'domain')]))
+            raise OSCCredentialsError(", ".join(missing))
+
+        ident_creds["auth_url"] = ident_creds["auth_url"].strip("\"'")
+        creds.update(
+            dict(
+                [
+                    (k, ident_creds.get(k))
+                    for k in all_attrs
+                    if k not in ("credentials_project", "domain")
+                ]
+            )
+        )
         if extra_attrs:
-            creds.update({'project_name': ident_creds['credentials_project'],
-                          'user_domain_name': ident_creds['domain'],
-                          'project_domain_name': ident_creds['domain'],
-                          })
+            creds.update(
+                {
+                    "project_name": ident_creds["credentials_project"],
+                    "user_domain_name": ident_creds["domain"],
+                    "project_domain_name": ident_creds["domain"],
+                }
+            )
         else:
-            creds['tenant_name'] = ident_creds['credentials_project']
+            creds["tenant_name"] = ident_creds["credentials_project"]
 
         return creds
 
     def get_keystone_credentials(self):
-        '''retrieve keystone credentials from either config or relation data
+        """Retrieve keystone credentials from either config or relation data
 
-        If config 'os-crendentials' is set, return that info otherwise look for a keystonecreds relation data'
+        If config 'os-crendentials' is set, return that info otherwise look
+        for a keystonecreds relation data'
 
         :return: dict of credential information for keystone
-        '''
-        return unitdata.kv().get('keystonecreds')
+        """
+        return unitdata.kv().get("keystonecreds")
 
     @property
     def nova_warn(self):
-        return self.charm_config.get('nova_warn')
+        return self.charm_config.get("nova_warn")
 
     @property
     def nova_crit(self):
-        return self.charm_config.get('nova_crit')
+        return self.charm_config.get("nova_crit")
 
     @property
     def nova_skip_aggregates(self):
-        skipped_aggregates = self.charm_config.get('skipped_host_aggregates')
+        skipped_aggregates = self.charm_config.get("skipped_host_aggregates")
         # We have to make sure there are no malicious injections in the code
         # as this gets passed to a python script via bash
-        regex = r'([\w_-]+(?:,[\w_-]+)*)'
+        regex = r"([\w_-]+(?:,[\w_-]+)*)"
         sanitized = ",".join(re.findall(regex, skipped_aggregates))
-        sanitized = [s for s in sanitized.split(',') if s != ""]
+        sanitized = [s for s in sanitized.split(",") if s != ""]
         sanitized = ",".join(sanitized)
         return sanitized
 
     @property
     def skip_disabled(self):
-        if self.charm_config.get('skip-disabled'):
-            return '--skip-disabled'
+        if self.charm_config.get("skip-disabled"):
+            return "--skip-disabled"
         else:
-            return ''
+            return ""
 
     @property
     def check_dns(self):
-        return self.charm_config.get('check-dns')
+        return self.charm_config.get("check-dns")
 
     def update_plugins(self):
-        charm_plugin_dir = os.path.join(hookenv.charm_dir(), 'files', 'plugins/')
-        host.rsync(charm_plugin_dir, self.plugins_dir, options=['--executability'])
+        charm_plugin_dir = os.path.join(hookenv.charm_dir(), "files", "plugins/")
+        host.rsync(charm_plugin_dir, self.plugins_dir, options=["--executability"])
 
     def _render_nova_checks(self, nrpe):
         """Nova services health."""
-        nova_check_command = os.path.join(self.plugins_dir, 'check_nova_services.py')
-        check_command = '{} --warn {} --crit {} --skip-aggregates {} {}'.format(
-            nova_check_command, self.nova_warn, self.nova_crit, self.nova_skip_aggregates,
-            self.skip_disabled).strip()
-        nrpe.add_check(shortname='nova_services',
-                       description='Check that enabled Nova services are up',
-                       check_cmd=check_command,
-                       )
+        nova_check_command = os.path.join(self.plugins_dir, "check_nova_services.py")
+        check_command = "{} --warn {} --crit {} --skip-aggregates {} {}".format(
+            nova_check_command,
+            self.nova_warn,
+            self.nova_crit,
+            self.nova_skip_aggregates,
+            self.skip_disabled,
+        ).strip()
+        nrpe.add_check(
+            shortname="nova_services",
+            description="Check that enabled Nova services are up",
+            check_cmd=check_command,
+        )
 
     def _render_neutron_checks(self, nrpe):
         """Neutron agents health."""
         if self.is_neutron_agents_check_enabled:
-            nrpe.add_check(shortname='neutron_agents',
-                           description='Check that enabled Neutron agents are up',
-                           check_cmd=os.path.join(self.plugins_dir,
-                                                  'check_neutron_agents.sh'),
-                           )
+            nrpe.add_check(
+                shortname="neutron_agents",
+                description="Check that enabled Neutron agents are up",
+                check_cmd=os.path.join(self.plugins_dir, "check_neutron_agents.sh"),
+            )
         else:
-            nrpe.remove_check(shortname='neutron_agents')
+            nrpe.remove_check(shortname="neutron_agents")
 
     def _render_cinder_checks(self, nrpe):
         # Cinder services health
-        cinder_check_command = os.path.join(self.plugins_dir, 'check_cinder_services.py')
-        check_command = '{} {}'.format(cinder_check_command, self.skip_disabled)
-        nrpe.add_check(shortname='cinder_services',
-                       description='Check that enabled Cinder services are up',
-                       check_cmd=check_command,
-                       )
+        cinder_check_command = os.path.join(
+            self.plugins_dir, "check_cinder_services.py"
+        )
+        check_command = "{} {}".format(cinder_check_command, self.skip_disabled)
+        nrpe.add_check(
+            shortname="cinder_services",
+            description="Check that enabled Cinder services are up",
+            check_cmd=check_command,
+        )
 
     def _remove_octavia_checks(self, nrpe):
-        for check in ('loadbalancers', 'amphorae', 'pools', 'image'):
-            nrpe.remove_check(shortname='octavia_{}'.format(check))
+        for check in ("loadbalancers", "amphorae", "pools", "image"):
+            nrpe.remove_check(shortname="octavia_{}".format(check))
 
     def _render_octavia_checks(self, nrpe):
         # only care about octavia after 18.04
-        if host.lsb_release()['DISTRIB_RELEASE'] < '18.04':
+        if host.lsb_release()["DISTRIB_RELEASE"] < "18.04":
             return
 
         # if its not enabled in config, remove checks
@@ -248,59 +276,65 @@ class OSCHelper():
             return
 
         # if its not listed as an endpoint, remove checks
-        if 'octavia' not in self.endpoint_service_names.values():
+        if "octavia" not in self.endpoint_service_names.values():
             self._remove_octavia_checks(nrpe)
             return
 
         # else, render the octavia service-specific checks
         fetch.apt_install(["python3-octaviaclient"], fatal=True)
-        script = os.path.join(self.plugins_dir, 'check_octavia.py')
+        script = os.path.join(self.plugins_dir, "check_octavia.py")
 
-        for check in ('loadbalancers', 'amphorae', 'pools', 'image'):
-            check_cmd = '{} --check {}'.format(script, check)
-            if check == 'image':
+        for check in ("loadbalancers", "amphorae", "pools", "image"):
+            check_cmd = "{} --check {}".format(script, check)
+            if check == "image":
                 check_cmd += " --amp-image-tag {}".format(self.octavia_amp_image_tag)
                 check_cmd += " --amp-image-days {}".format(self.octavia_amp_image_days)
-            ignore = self.charm_config.get('octavia-%s-ignored' % check)
+            ignore = self.charm_config.get("octavia-%s-ignored" % check)
             if ignore:
-                check_cmd += ' --ignored {}'.format(ignore)
+                check_cmd += " --ignored {}".format(ignore)
             nrpe.add_check(
-                shortname='octavia_{}'.format(check),
-                description='Check octavia {} status'.format(check),
+                shortname="octavia_{}".format(check),
+                description="Check octavia {} status".format(check),
                 check_cmd=check_cmd,
             )
 
     def _render_contrail_checks(self, nrpe):
         if self.contrail_analytics_vip:
-            contrail_check_command = '{} --host {}'.format(
-                os.path.join(self.plugins_dir, 'check_contrail_analytics_alarms.py'),
-                self.contrail_analytics_vip)
+            contrail_check_command = "{} --host {}".format(
+                os.path.join(self.plugins_dir, "check_contrail_analytics_alarms.py"),
+                self.contrail_analytics_vip,
+            )
             if self.contrail_ignored:
-                contrail_check_command += ' --ignored {}'.format(
-                    self.contrail_ignored
-                )
-            nrpe.add_check(shortname='contrail_analytics_alarms',
-                           description='Check Contrail Analytics alarms',
-                           check_cmd=contrail_check_command,
-                           )
+                contrail_check_command += " --ignored {}".format(self.contrail_ignored)
+            nrpe.add_check(
+                shortname="contrail_analytics_alarms",
+                description="Check Contrail Analytics alarms",
+                check_cmd=contrail_check_command,
+            )
         else:
-            nrpe.remove_check(shortname='contrail_analytics_alarms')
+            nrpe.remove_check(shortname="contrail_analytics_alarms")
 
     def _render_dns_checks(self, nrpe):
         if len(self.check_dns):
-            nrpe.add_check(shortname='dns_multi',
-                           description='Check DNS names are resolvable',
-                           check_cmd='{} {}'.format(
-                               os.path.join(self.plugins_dir,
-                                            'check_dns_multi.sh'),
-                               ' '.join(self.check_dns.split())),
-                           )
+            nrpe.add_check(
+                shortname="dns_multi",
+                description="Check DNS names are resolvable",
+                check_cmd="{} {}".format(
+                    os.path.join(self.plugins_dir, "check_dns_multi.sh"),
+                    " ".join(self.check_dns.split()),
+                ),
+            )
         else:
-            nrpe.remove_check(shortname='dns_multi')
+            nrpe.remove_check(shortname="dns_multi")
 
     def render_checks(self, creds):
-        render(source='nagios.novarc', target=self.novarc, context=creds,
-               owner='nagios', group='nagios')
+        render(
+            source="nagios.novarc",
+            target=self.novarc,
+            context=creds,
+            owner="nagios",
+            group="nagios",
+        )
 
         nrpe = NRPE()
         if not os.path.exists(self.plugins_dir):
@@ -333,12 +367,12 @@ class OSCHelper():
         :returns: str
         :rtype: Tuple[str, str]
         """
-        if netloc.find(':') == -1:
+        if netloc.find(":") == -1:
             # no port specified
             host = netloc
-            port = 80 if scheme == 'http' else 443
+            port = 80 if scheme == "http" else 443
         else:
-            host, port = netloc.split(':')
+            host, port = netloc.split(":")
 
         return host, port
 
@@ -352,31 +386,32 @@ class OSCHelper():
         If SSL, add a check for the cert.
 
         v2 endpoint needs the 'interface' attribute:
-        <Endpoint {'id': 'XXXXX', 'region': 'RegionOne', 'publicurl': 'http://10.x.x.x:9696',
-        'service_id': 'YYY', 'internalurl': 'http://10.x.x.x:9696', 'enabled': True,
+        <Endpoint {'id': 'XXXXX', 'region': 'RegionOne',
+        'publicurl': 'http://10.x.x.x:9696', 'service_id': 'YYY',
+        'internalurl': 'http://10.x.x.x:9696', 'enabled': True,
         'adminurl': 'http://10.x.x.x:9696'}>
         """
         # provide URLs that can be used for healthcheck for some services
         # This also provides a nasty hack-ish way to add switches if we need
         # for some services.
         health_check_params = {
-            'aodh': '/healthcheck',
-            'barbican': '/v1 -e Unauthorized',
-            'ceilometer': '/ -e Unauthorized -d x-openstack-request-id',
-            'cinderv1': '/v1 -e Unauthorized -d x-openstack-request-id',
-            'cinderv2': '/v2 -e Unauthorized',
-            'cinderv3': '/v3 -e Unauthorized -d x-openstack-request-id',
-            'designate': '/v2 -e Unauthorized',
-            'glance': '/healthcheck',
-            'gnocchi': '/v1 -e Unauthorized',
-            'heat': '/v1 -e Unauthorized',
-            'keystone': '/healthcheck',
-            'nova': '/healthcheck',
-            'octavia': '/v2 -e Unauthorized',
-            'placement': '/healthcheck -e Unauthorized -d x-openstack-request-id',
-            's3': self.charm_config.get('s3_check_params', '/'),
-            'swift': self.charm_config.get('swift_check_params', '/'),
-            }
+            "aodh": "/healthcheck",
+            "barbican": "/v1 -e Unauthorized",
+            "ceilometer": "/ -e Unauthorized -d x-openstack-request-id",
+            "cinderv1": "/v1 -e Unauthorized -d x-openstack-request-id",
+            "cinderv2": "/v2 -e Unauthorized",
+            "cinderv3": "/v3 -e Unauthorized -d x-openstack-request-id",
+            "designate": "/v2 -e Unauthorized",
+            "glance": "/healthcheck",
+            "gnocchi": "/v1 -e Unauthorized",
+            "heat": "/v1 -e Unauthorized",
+            "keystone": "/healthcheck",
+            "nova": "/healthcheck",
+            "octavia": "/v2 -e Unauthorized",
+            "placement": "/healthcheck -e Unauthorized -d x-openstack-request-id",
+            "s3": self.charm_config.get("s3_check_params", "/"),
+            "swift": self.charm_config.get("swift_check_params", "/"),
+        }
 
         self.get_keystone_client(creds)
         nrpe = NRPE()
@@ -384,19 +419,19 @@ class OSCHelper():
 
         for endpoint in self.keystone_endpoints:
             service_name = self.endpoint_service_names[endpoint.id]
-            endpoint.healthcheck_url = health_check_params.get(service_name, '/')
+            endpoint.healthcheck_url = health_check_params.get(service_name, "/")
 
             # Note(aluria): glance-simplestreams-sync does not provide an API to check
-            if service_name == 'image-stream':
+            if service_name == "image-stream":
                 continue
 
-            if not hasattr(endpoint, 'interface'):
+            if not hasattr(endpoint, "interface"):
                 # Note(aluria): filter:healthcheck is not configured in Keystone v2
                 # https://docs.openstack.org/keystone/pike/configuration.html#health-check-middleware
-                if service_name == 'keystone':
+                if service_name == "keystone":
                     continue
-                for interface in 'admin internal public'.split():
-                    old_interface_name = '{}url'.format(interface)
+                for interface in "admin internal public".split():
+                    old_interface_name = "{}url".format(interface)
                     if not hasattr(endpoint, old_interface_name):
                         continue
                     endpoint.interface = interface
@@ -404,51 +439,70 @@ class OSCHelper():
                     break
 
             check_url = urlparse(endpoint.url)
-            if not self.charm_config.get('check_{}_urls'.format(endpoint.interface)):
-                nrpe.remove_check(shortname='{}_{}'.format(service_name, endpoint.interface))
-                if check_url.scheme == 'https':
-                    nrpe.remove_check(shortname='{}_{}_cert'.format(service_name, endpoint.interface))
+            if not self.charm_config.get("check_{}_urls".format(endpoint.interface)):
+                nrpe.remove_check(
+                    shortname="{}_{}".format(service_name, endpoint.interface)
+                )
+                if check_url.scheme == "https":
+                    nrpe.remove_check(
+                        shortname="{}_{}_cert".format(service_name, endpoint.interface)
+                    )
                 continue
 
-            cmd_params = ['/usr/lib/nagios/plugins/check_http']
+            cmd_params = ["/usr/lib/nagios/plugins/check_http"]
             host, port = self._split_url(check_url.netloc, check_url.scheme)
-            cmd_params.append('-H {} -p {}'.format(host, port))
-            cmd_params.append('-u {}'.format(endpoint.healthcheck_url))
+            cmd_params.append("-H {} -p {}".format(host, port))
+            cmd_params.append("-u {}".format(endpoint.healthcheck_url))
 
             # if this is https, we want to add a check for cert expiry
             # also need to tell check_http use use TLS
-            if check_url.scheme == 'https':
-                cmd_params.append('-S')
+            if check_url.scheme == "https":
+                cmd_params.append("-S")
                 # Add an extra check for TLS cert expiry
                 cmd_params_cert = cmd_params.copy()
-                cmd_params_cert.append('-C {},{}'.format(self.charm_config['tls_warn_days'] or 30,
-                                                         self.charm_config['tls_crit_days'] or 14))
-                nrpe.add_check(shortname='{}_{}_cert'.format(service_name, endpoint.interface),
-                               description='Certificate expiry check for {} {}'.format(service_name,
-                                                                                       endpoint.interface),
-                               check_cmd=' '.join(cmd_params_cert))
-                hookenv.log("Added cert expiry check for: {}, {}".format(service_name, endpoint.interface))
+                cmd_params_cert.append(
+                    "-C {},{}".format(
+                        self.charm_config["tls_warn_days"] or 30,
+                        self.charm_config["tls_crit_days"] or 14,
+                    )
+                )
+                nrpe.add_check(
+                    shortname="{}_{}_cert".format(service_name, endpoint.interface),
+                    description="Certificate expiry check for {} {}".format(
+                        service_name, endpoint.interface
+                    ),
+                    check_cmd=" ".join(cmd_params_cert),
+                )
+                hookenv.log(
+                    "Added cert expiry check for: {}, {}".format(
+                        service_name, endpoint.interface
+                    )
+                )
 
             # Add the actual health check for the URL
-            nrpe_shortname = '{}_{}'.format(service_name, endpoint.interface)
-            nrpe.add_check(shortname=nrpe_shortname,
-                           description='Endpoint url check for {} {}'.format(service_name, endpoint.interface),
-                           check_cmd=' '.join(cmd_params))
+            nrpe_shortname = "{}_{}".format(service_name, endpoint.interface)
+            nrpe.add_check(
+                shortname=nrpe_shortname,
+                description="Endpoint url check for {} {}".format(
+                    service_name, endpoint.interface
+                ),
+                check_cmd=" ".join(cmd_params),
+            )
             configured_endpoint_checks[nrpe_shortname] = True
-            hookenv.log("Added nrpe check {}: {}".format(nrpe_shortname, ' '.join(cmd_params)))
+            hookenv.log(
+                "Added nrpe check {}: {}".format(nrpe_shortname, " ".join(cmd_params))
+            )
         nrpe.write()
         self._remove_old_nrpe_endpoint_checks(nrpe, configured_endpoint_checks)
 
     def _remove_old_nrpe_endpoint_checks(self, nrpe, configured_endpoint_checks):
-        """Loop through the old and new endpoint checks, if there are checks that aren't needed any more,
-        remove them.
-        """
+        """Remove old endpoint checks that are no longer currently defined."""
         kv = unitdata.kv()
-        endpoint_delta = kv.delta(configured_endpoint_checks, 'endpoint_checks')
-        kv.update(configured_endpoint_checks, 'endpoint_checks')
+        endpoint_delta = kv.delta(configured_endpoint_checks, "endpoint_checks")
+        kv.update(configured_endpoint_checks, "endpoint_checks")
         for nrpe_shortname in endpoint_delta.items():
-            # generates tuples of the format ('heat_public', Delta(previous=None, current=True))
-            # remove any that are not current
+            # generates tuples of below format, remove any that are not current
+            # ('heat_public', Delta(previous=None, current=True))
             if not nrpe_shortname[1].current:
                 nrpe.remove_check(shortname=nrpe_shortname[0])
         nrpe.write()
@@ -468,17 +522,23 @@ class OSCHelper():
 
         # don't try to initialize a client without credentials
         if creds is None:
-            raise OSCKeystoneServerError('Unable to list the endpoints yet: '
-                                         'no credentials provided.')
+            raise OSCKeystoneServerError(
+                "Unable to list the endpoints yet: no credentials provided."
+            )
 
-        if int(creds.get('auth_version', 0)) >= 3:
+        if int(creds.get("auth_version", 0)) >= 3:
             from keystoneclient.v3 import client
             from keystoneclient.auth.identity import v3 as kst_version
-            auth_fields = 'username password auth_url user_domain_name project_domain_name project_name'.split()
+
+            auth_fields = (
+                "username password auth_url user_domain_name "
+                "project_domain_name project_name"
+            ).split()
         else:
             from keystoneclient.v2_0 import client
             from keystoneclient.auth.identity import v2 as kst_version
-            auth_fields = 'username password auth_url tenant_name'.split()
+
+            auth_fields = "username password auth_url tenant_name".split()
 
         auth_creds = dict([(key, creds.get(key)) for key in auth_fields])
         auth = kst_version.Password(**auth_creds)
@@ -486,18 +546,20 @@ class OSCHelper():
         self._keystone_client = client.Client(session=sess)
 
         if self._keystone_client is None:
-            raise OSCKeystoneServerError('Unable to list the endpoints yet: '
-                                         'could not connect to the Identity Service')
+            raise OSCKeystoneServerError(
+                "Unable to list the endpoints yet: "
+                "could not connect to the Identity Service"
+            )
 
     @property
     def keystone_endpoints(self):
-        endpoints = self._safe_keystone_client_list('endpoints')
+        endpoints = self._safe_keystone_client_list("endpoints")
         hookenv.log("Endpoints from keystone: {}".format(endpoints))
         return endpoints
 
     @property
     def keystone_services(self):
-        services = self._safe_keystone_client_list('services')
+        services = self._safe_keystone_client_list("services")
         hookenv.log("Services from keystone: {}".format(services))
         return services
 
@@ -520,28 +582,40 @@ class OSCHelper():
         list_command = getattr(self._keystone_client, object_type).list
         try:
             response = list_command()
-        except (keystoneauth1.exceptions.http.InternalServerError,
-                keystoneauth1.exceptions.connection.ConnectFailure) as server_error:
+        except (
+            keystoneauth1.exceptions.http.InternalServerError,
+            keystoneauth1.exceptions.connection.ConnectFailure,
+        ) as server_error:
             raise OSCKeystoneServerError(
-                'Keystone server unable to list keystone {}: {}'.format(server_error, object_type))
+                "Keystone server unable to list keystone {}: {}".format(
+                    server_error, object_type
+                )
+            )
         except keystoneauth1.exceptions.http.BadRequest as client_error:
             raise OSCKeystoneClientError(
-                'Keystone client error when listing {}: {}'.format(client_error, object_type))
+                "Keystone client error when listing {}: {}".format(
+                    client_error, object_type
+                )
+            )
         except keystoneauth1.exceptions.connection.SSLError as ssl_error:
-            raise OSCSslError('Keystone ssl error when listing {}: {}'.format(ssl_error, object_type))
+            raise OSCSslError(
+                "Keystone ssl error when listing {}: {}".format(ssl_error, object_type)
+            )
         return response
 
     @property
-    def _load_envvars(self, novarc='/var/lib/nagios/nagios.novarc'):
+    def _load_envvars(self, novarc="/var/lib/nagios/nagios.novarc"):
         if not os.path.exists(novarc):
             return False
 
-        output = subprocess.check_output(['/bin/bash', '-c', 'source {} && env'.format(novarc)])
+        output = subprocess.check_output(
+            ["/bin/bash", "-c", "source {} && env".format(novarc)]
+        )
         i = 0
-        for line in output.decode('utf-8').splitlines():
-            if not line.startswith('OS_'):
+        for line in output.decode("utf-8").splitlines():
+            if not line.startswith("OS_"):
                 continue
-            key, value = line.split('=')
+            key, value = line.split("=")
             os.environ[key] = value
             i += 1
 
@@ -551,7 +625,7 @@ class OSCHelper():
         try:
             pwd.getpwnam(user)
             # preserve envvars and run as `user`
-            cmd = ['sudo', '-Eu', user]
+            cmd = ["sudo", "-Eu", user]
 
             # convert command into a list
             if isinstance(user_cmd, str):
@@ -560,48 +634,58 @@ class OSCHelper():
             elif isinstance(user_cmd, list):
                 cmd.extend(user_cmd)
             else:
-                hookenv.log("_run_as - can't run as user {} the command: {}".format(user, user_cmd))
+                hookenv.log(
+                    "_run_as - can't run as user {} the command: {}".format(
+                        user, user_cmd
+                    )
+                )
                 return False
 
             subprocess.check_call(cmd)
             return True
 
         except KeyError as error:
-            hookenv.log('_run_as - user does not exist => {}'.format(str(error)))
+            hookenv.log("_run_as - user does not exist => {}".format(str(error)))
             return False
         except subprocess.CalledProcessError as error:
-            hookenv.log('_run_as - cmd failed => {}'.format(str(error)))
+            hookenv.log("_run_as - cmd failed => {}".format(str(error)))
             if error.stderr:
-                hookenv.log('_run_as stderr => {}'.format(error.stderr))
+                hookenv.log("_run_as stderr => {}".format(error.stderr))
             if error.stdout:
-                hookenv.log('_run_as stderr => {}'.format(error.stdout))
+                hookenv.log("_run_as stderr => {}".format(error.stdout))
             return False
 
     @property
     def _rallyuser(self):
-        return 'nagiososc'
+        return "nagiososc"
 
     def install_rally(self):
         kv = unitdata.kv()
-        if kv.get('rallyinstalled', False):
+        if kv.get("rallyinstalled", False):
             return True
 
         if not self._load_envvars:
-            hookenv.log('install_rally - could not load nagios.novarc')
+            hookenv.log("install_rally - could not load nagios.novarc")
             return False
 
         user = self._rallyuser
         host.adduser(user)
-        host.mkdir(os.path.join('/home', user), owner=user, group=user, perms=0o755, force=False)
-
-        for tool in ['rally', 'tempest']:
-            toolname = 'fcbtest.{}init'.format(tool)
+        host.mkdir(
+            os.path.join("/home", user),
+            owner=user,
+            group=user,
+            perms=0o755,
+            force=False,
+        )
+
+        for tool in ["rally", "tempest"]:
+            toolname = "fcbtest.{}init".format(tool)
             installed = self._run_as(user, [toolname])
             if not installed:
-                hookenv.log('install_rally - could not initialize {}'.format(tool))
+                hookenv.log("install_rally - could not initialize {}".format(tool))
                 return False
 
-        kv.set('rallyinstalled', True)
+        kv.set("rallyinstalled", True)
         return True
 
     def _regenerate_tempest_conf(self, tempestfile):
@@ -610,18 +694,18 @@ class OSCHelper():
         for section in config.keys():
             for key, value in config[section].items():
                 try:
-                    if section != 'DEFAULT' and key in config['DEFAULT'].keys():
-                        # avoid copying the DEFAULT config options to the rest of sections
+                    if section != "DEFAULT" and key in config["DEFAULT"].keys():
+                        # avoid copying the DEFAULT config options to remaining sections
                         continue
                 except KeyError:
                     # DEFAULT section does not exist
                     pass
 
                 # Enable Cinder, which is a default OpenStack service
-                if section == 'service_available' and key == 'cinder':
-                    config[section][key] = 'True'
+                if section == "service_available" and key == "cinder":
+                    config[section][key] = "True"
 
-        with open(tempestfile, 'w') as fd:
+        with open(tempestfile, "w") as fd:
             config.write(fd)
 
     def reconfigure_tempest(self):
@@ -633,22 +717,25 @@ class OSCHelper():
         RALLY_DEPLOYMENT=a75657c6-9eea-4f00-9117-2580fe056a80
         RALLY_ENV=a75657c6-9eea-4f00-9117-2580fe056a80
         """
-        RALLY_CONF = ['/home', self._rallyuser, 'snap', 'fcbtest', 'current', '.rally']
-        rally_globalconfig = os.path.join(*RALLY_CONF, 'globals')
+        RALLY_CONF = ["/home", self._rallyuser, "snap", "fcbtest", "current", ".rally"]
+        rally_globalconfig = os.path.join(*RALLY_CONF, "globals")
         if not os.path.isfile(rally_globalconfig):
             return False
 
-        uuids = collections.defaultdict(lambda: '*')
-        with open(rally_globalconfig, 'r') as fd:
+        uuids = collections.defaultdict(lambda: "*")
+        with open(rally_globalconfig, "r") as fd:
             for line in fd.readlines():
-                key, value = line.strip().split('=')
-                if key in ['RALLY_VERIFIER', 'RALLY_DEPLOYMENT']:
+                key, value = line.strip().split("=")
+                if key in ["RALLY_VERIFIER", "RALLY_DEPLOYMENT"]:
                     uuids[key] = value
 
-        tempest_path = os.path.join(*RALLY_CONF, 'verification',
-                                    'verifier-{RALLY_VERIFIER}'.format(**uuids),
-                                    'for-deployment-{RALLY_DEPLOYMENT}'.format(**uuids),
-                                    'tempest.conf')
+        tempest_path = os.path.join(
+            *RALLY_CONF,
+            "verification",
+            "verifier-{RALLY_VERIFIER}".format(**uuids),
+            "for-deployment-{RALLY_DEPLOYMENT}".format(**uuids),
+            "tempest.conf"
+        )
         tempestfile = glob.glob(tempest_path)
         if len(tempestfile) == 0:
             # No tempest.conf file generated, yet
@@ -663,7 +750,7 @@ class OSCHelper():
     def _get_rally_checks_context(self):
         os_components_skip_list = self.skipped_rally_checks
         ctxt = {}
-        for comp in 'cinder glance nova neutron'.split():
+        for comp in "cinder glance nova neutron".split():
             ctxt.update({comp: comp not in os_components_skip_list})
         return ctxt
 
@@ -672,53 +759,66 @@ class OSCHelper():
             return
 
         # Copy run_rally.sh to /usr/local/bin
-        rally_script = os.path.join(hookenv.charm_dir(), 'files', 'run_rally.py')
-        host.rsync(rally_script, self.scripts_dir, options=['--executability'])
-
-        ostestsfile = os.path.join('/home', self._rallyuser, 'ostests.txt')
-        render(source='ostests.txt.j2', target=ostestsfile,
-               context=self._get_rally_checks_context(),
-               owner=self._rallyuser, group=self._rallyuser)
+        rally_script = os.path.join(hookenv.charm_dir(), "files", "run_rally.py")
+        host.rsync(rally_script, self.scripts_dir, options=["--executability"])
+
+        ostestsfile = os.path.join("/home", self._rallyuser, "ostests.txt")
+        render(
+            source="ostests.txt.j2",
+            target=ostestsfile,
+            context=self._get_rally_checks_context(),
+            owner=self._rallyuser,
+            group=self._rallyuser,
+        )
 
         proxy_settings = hookenv.env_proxy_settings()
         if proxy_settings:
-            content = '\n'.join(['{}={}'.format(proxy_var, proxy_var_val)
-                                 for proxy_var, proxy_var_val in proxy_settings.items()])
+            content = "\n".join(
+                [
+                    "{}={}".format(proxy_var, proxy_var_val)
+                    for proxy_var, proxy_var_val in proxy_settings.items()
+                ]
+            )
         else:
-            content = ''
+            content = ""
 
         context = {
-            'schedule': self.rally_cron_schedule,
-            'user': self._rallyuser,
-            'cmd': os.path.join(self.scripts_dir, 'run_rally.py'),
+            "schedule": self.rally_cron_schedule,
+            "user": self._rallyuser,
+            "cmd": os.path.join(self.scripts_dir, "run_rally.py"),
         }
-        content += '\n#\n{schedule} {user} timeout -k 840s -s SIGTERM 780s {cmd}'.format(**context)
-        with open(self.rally_cron_file, 'w') as fd:
-            fd.write('# Juju generated - DO NOT EDIT\n{}\n\n'.format(content))
+        content += (
+            "\n#\n{schedule} {user} timeout -k 840s -s SIGTERM 780s {cmd}".format(
+                **context
+            )
+        )
+        with open(self.rally_cron_file, "w") as fd:
+            fd.write("# Juju generated - DO NOT EDIT\n{}\n\n".format(content))
 
     def configure_rally_check(self):
         kv = unitdata.kv()
-        if kv.get('rallyconfigured', False):
+        if kv.get("rallyconfigured", False):
             return
 
         self.update_rally_checkfiles()
-        rally_check = os.path.join(self.plugins_dir, 'check_rally.py')
+        rally_check = os.path.join(self.plugins_dir, "check_rally.py")
         nrpe = NRPE()
-        nrpe.add_check(shortname='rally',
-                       description='Check that all rally tests pass',
-                       check_cmd=rally_check,
-                       )
+        nrpe.add_check(
+            shortname="rally",
+            description="Check that all rally tests pass",
+            check_cmd=rally_check,
+        )
         nrpe.write()
-        kv.set('rallyconfigured', True)
+        kv.set("rallyconfigured", True)
 
     def remove_rally_check(self):
         filename = self.rally_cron_file
         if os.path.exists(filename):
             os.unlink(filename)
 
-        if os.path.exists('/etc/nagios/nrpe.d/check_rally.cfg'):
+        if os.path.exists("/etc/nagios/nrpe.d/check_rally.cfg"):
             nrpe = NRPE()
-            nrpe.remove_check(shortname='rally')
+            nrpe.remove_check(shortname="rally")
             nrpe.write()
 
     def deploy_rally(self):
@@ -729,5 +829,5 @@ class OSCHelper():
             self.configure_rally_check()
         else:
             self.remove_rally_check()
-            unitdata.kv().set('rallyconfigured', False)
+            unitdata.kv().set("rallyconfigured", False)
         return True
diff --git a/src/reactive/openstack_service_checks.py b/src/reactive/openstack_service_checks.py
index f8d5a77..ede8c79 100644
--- a/src/reactive/openstack_service_checks.py
+++ b/src/reactive/openstack_service_checks.py
@@ -19,25 +19,32 @@ import base64
 import subprocess
 
 from charmhelpers.core import hookenv, host, unitdata
-from charms.reactive import any_flags_set, clear_flag, is_flag_set, set_flag, when, when_not
+from charms.reactive import (
+    any_flags_set,
+    clear_flag,
+    is_flag_set,
+    set_flag,
+    when,
+    when_not,
+)
 
 from lib_openstack_service_checks import (
     OSCHelper,
     OSCCredentialsError,
-    OSCKeystoneError
+    OSCKeystoneError,
 )
 
-CERT_FILE = '/usr/local/share/ca-certificates/openstack-service-checks.crt'
+CERT_FILE = "/usr/local/share/ca-certificates/openstack-service-checks.crt"
 helper = OSCHelper()
 
 
-@when('config.changed')
+@when("config.changed")
 def config_changed():
-    clear_flag('openstack-service-checks.configured')
+    clear_flag("openstack-service-checks.configured")
 
 
-@when_not('openstack-service-checks.installed')
-@when('nrpe-external-master.available')
+@when_not("openstack-service-checks.installed")
+@when("nrpe-external-master.available")
 def install_openstack_service_checks():
     """Entry point to start configuring the unit
 
@@ -45,22 +52,21 @@ def install_openstack_service_checks():
     Some relation data can be initialized if the application is related to
     keystone.
     """
-    set_flag('openstack-service-checks.installed')
-    clear_flag('openstack-service-checks.configured')
+    set_flag("openstack-service-checks.installed")
+    clear_flag("openstack-service-checks.configured")
 
 
-@when_not('identity-credentials.available')
-@when('identity-credentials.connected')
+@when_not("identity-credentials.available")
+@when("identity-credentials.connected")
 def configure_ident_username(keystone):
-    """Requests a user to the Identity Service
-    """
-    username = 'nagios'
+    """Requests a user to the Identity Service"""
+    username = "nagios"
     keystone.request_credentials(username)
-    clear_flag('openstack-service-checks.stored-creds')
+    clear_flag("openstack-service-checks.stored-creds")
 
 
-@when_not('openstack-service-checks.stored-creds')
-@when('identity-credentials.available')
+@when_not("openstack-service-checks.stored-creds")
+@when("identity-credentials.available")
 def save_creds(keystone):
     """Collect and save credentials from Keystone relation.
 
@@ -68,47 +74,53 @@ def save_creds(keystone):
     reformat them into something the Keystone client can use, and
     save them into the unitdata.
     """
-    creds = {'username': keystone.credentials_username(),
-             'password': keystone.credentials_password(),
-             'region': keystone.region(),
-             }
-    if keystone.api_version() == '3':
-        api_url = 'v3'
+    creds = {
+        "username": keystone.credentials_username(),
+        "password": keystone.credentials_password(),
+        "region": keystone.region(),
+    }
+    if keystone.api_version() == "3":
+        api_url = "v3"
         try:
             domain = keystone.domain()
         except AttributeError:
-            domain = 'service_domain'
+            domain = "service_domain"
         # keystone relation sends info back with funny names, fix here
-        creds.update({'project_name': keystone.credentials_project(),
-                      'auth_version': '3',
-                      'user_domain_name': domain,
-                      'project_domain_name': domain})
+        creds.update(
+            {
+                "project_name": keystone.credentials_project(),
+                "auth_version": "3",
+                "user_domain_name": domain,
+                "project_domain_name": domain,
+            }
+        )
     else:
-        api_url = 'v2.0'
-        creds['tenant_name'] = keystone.credentials_project()
+        api_url = "v2.0"
+        creds["tenant_name"] = keystone.credentials_project()
 
-    creds['auth_url'] = '{proto}://{host}:{port}/{api_url}'.format(
-        proto=keystone.auth_protocol(), host=keystone.auth_host(),
-        port=keystone.auth_port(), api_url=api_url)
+    creds["auth_url"] = "{proto}://{host}:{port}/{api_url}".format(
+        proto=keystone.auth_protocol(),
+        host=keystone.auth_host(),
+        port=keystone.auth_port(),
+        api_url=api_url,
+    )
 
     helper.store_keystone_credentials(creds)
-    set_flag('openstack-service-checks.stored-creds')
-    clear_flag('openstack-service-checks.configured')
+    set_flag("openstack-service-checks.stored-creds")
+    clear_flag("openstack-service-checks.configured")
 
 
-@when_not('identity-credentials.connected')
-@when_not('identity-credentials.available')
-@when('openstack-service-checks.stored-creds')
+@when_not("identity-credentials.connected")
+@when_not("identity-credentials.available")
+@when("openstack-service-checks.stored-creds")
 def allow_keystone_store_overwrite():
-    """Allow unitdata overwrite if keystone relation is recycled.
-    """
-    clear_flag('openstack-service-checks.stored-creds')
+    """Allow unitdata overwrite if keystone relation is recycled."""
+    clear_flag("openstack-service-checks.stored-creds")
 
 
-@when('identity-credentials.available.updated')
+@when("identity-credentials.available.updated")
 def update_keystone_store():
-    """when identity-service-relation-changed is triggered, update the stored credentials
-    """
+    """Update stored credentials when identity-service-relation-changed is triggered."""
     allow_keystone_store_overwrite()
 
 
@@ -123,15 +135,16 @@ def get_credentials():
     except OSCCredentialsError as error:
         creds = helper.get_keystone_credentials()
         if not creds:
-            hookenv.log('render_config: No credentials yet, skipping')
-            hookenv.status_set('blocked',
-                               'Missing os-credentials vars: {}'.format(error))
+            hookenv.log("render_config: No credentials yet, skipping")
+            hookenv.status_set(
+                "blocked", "Missing os-credentials vars: {}".format(error)
+            )
             return
     return creds
 
 
-@when('openstack-service-checks.installed')
-@when_not('openstack-service-checks.configured')
+@when("openstack-service-checks.installed")
+@when_not("openstack-service-checks.configured")
 def render_config():
     """Render nrpe checks from the templates
 
@@ -142,11 +155,10 @@ def render_config():
     Furthermore, juju config os-credentials take precedence over keystone
     related data.
     """
+
     def block_tls_failure(error):
-        hookenv.log('update-ca-certificates failed: {}'.format(error),
-                    hookenv.ERROR)
-        hookenv.status_set('blocked',
-                           'update-ca-certificates error. check logs')
+        hookenv.log("update-ca-certificates failed: {}".format(error), hookenv.ERROR)
+        hookenv.status_set("blocked", "update-ca-certificates error. check logs")
         return
 
     creds = get_credentials()
@@ -154,14 +166,14 @@ def render_config():
         return
 
     # Fix TLS
-    if helper.charm_config['trusted_ssl_ca'].strip():
-        trusted_ssl_ca = helper.charm_config['trusted_ssl_ca'].strip()
-        hookenv.log('Writing ssl ca cert:{}'.format(trusted_ssl_ca))
+    if helper.charm_config["trusted_ssl_ca"].strip():
+        trusted_ssl_ca = helper.charm_config["trusted_ssl_ca"].strip()
+        hookenv.log("Writing ssl ca cert:{}".format(trusted_ssl_ca))
         cert_content = base64.b64decode(trusted_ssl_ca).decode()
         try:
-            with open(CERT_FILE, 'w') as fd:
+            with open(CERT_FILE, "w") as fd:
                 fd.write(cert_content)
-            subprocess.call(['/usr/sbin/update-ca-certificates'])
+            subprocess.call(["/usr/sbin/update-ca-certificates"])
 
         except subprocess.CalledProcessError as error:
             block_tls_failure(error)
@@ -170,12 +182,14 @@ def render_config():
             block_tls_failure(error)
             return
 
-    hookenv.log('render_config: Got credentials for'
-                ' username={}'.format(creds.get('username')))
+    hookenv.log(
+        "render_config: Got credentials for"
+        " username={}".format(creds.get("username"))
+    )
 
     try:
         helper.render_checks(creds)
-        set_flag('openstack-service-checks.endpoints.configured')
+        set_flag("openstack-service-checks.endpoints.configured")
     except OSCKeystoneError as keystone_error:
         _set_keystone_error_workload_status(keystone_error)
 
@@ -183,13 +197,13 @@ def render_config():
         # Rally could not be installed (if enabled). No further actions taken
         return
 
-    set_flag('openstack-service-checks.configured')
-    clear_flag('openstack-service-checks.started')
+    set_flag("openstack-service-checks.configured")
+    clear_flag("openstack-service-checks.started")
 
 
-@when('openstack-service-checks.installed')
-@when('openstack-service-checks.configured')
-@when_not('openstack-service-checks.endpoints.configured')
+@when("openstack-service-checks.installed")
+@when("openstack-service-checks.configured")
+@when_not("openstack-service-checks.endpoints.configured")
 def configure_nrpe_endpoints():
     """Create an NRPE check for each Keystone catalog endpoint.
 
@@ -205,94 +219,101 @@ def configure_nrpe_endpoints():
 
     try:
         helper.create_endpoint_checks(creds)
-        set_flag('openstack-service-checks.endpoints.configured')
-        clear_flag('openstack-service-checks.started')
+        set_flag("openstack-service-checks.endpoints.configured")
+        clear_flag("openstack-service-checks.started")
     except OSCKeystoneError as keystone_error:
         _set_keystone_error_workload_status(keystone_error)
 
 
-@when('identity-notifications.available.updated')
+@when("identity-notifications.available.updated")
 def endpoints_changed():
-    clear_flag('openstack-service-checks.endpoints.configured')
+    clear_flag("openstack-service-checks.endpoints.configured")
 
 
-@when('openstack-service-checks.configured')
-@when_not('openstack-service-checks.started')
+@when("openstack-service-checks.configured")
+@when_not("openstack-service-checks.started")
 def do_restart():
-    hookenv.log('Reloading nagios-nrpe-server')
-    host.service_restart('nagios-nrpe-server')
-    set_flag('openstack-service-checks.started')
+    hookenv.log("Reloading nagios-nrpe-server")
+    host.service_restart("nagios-nrpe-server")
+    set_flag("openstack-service-checks.started")
 
 
-@when('openstack-service-checks.started')
-@when('openstack-service-checks.endpoints.configured')
+@when("openstack-service-checks.started")
+@when("openstack-service-checks.endpoints.configured")
 def set_active():
-    hookenv.status_set('active', 'Unit is ready')
+    hookenv.status_set("active", "Unit is ready")
 
 
-@when('nrpe-external-master.available')
+@when("nrpe-external-master.available")
 def do_reconfigure_nrpe():
-    os_credentials_flag = 'config.changed.os-credentials'
-    flags = ['config.changed.check_{}_urls'.format(interface) for interface in ['admin', 'internal', 'public']]
+    os_credentials_flag = "config.changed.os-credentials"
+    flags = [
+        "config.changed.check_{}_urls".format(interface)
+        for interface in ["admin", "internal", "public"]
+    ]
     flags.extend(os_credentials_flag)
 
-    if is_flag_set('config.changed'):
-        clear_flag('openstack-service-checks.configured')
+    if is_flag_set("config.changed"):
+        clear_flag("openstack-service-checks.configured")
 
     if any_flags_set(*flags):
         if is_flag_set(os_credentials_flag):
-            clear_flag('openstack-service-checks.configured')
-        clear_flag('openstack-service-checks.endpoints.configured')
+            clear_flag("openstack-service-checks.configured")
+        clear_flag("openstack-service-checks.endpoints.configured")
 
     if helper.is_rally_enabled:
         helper.reconfigure_tempest()
 
-        if is_flag_set('config.changed.skip-rally'):
+        if is_flag_set("config.changed.skip-rally"):
             helper.update_rally_checkfiles()
 
 
-@when_not('nrpe-external-master.available')
+@when_not("nrpe-external-master.available")
 def missing_nrpe():
-    """Avoid a user action to be missed or overwritten by another hook
-    """
-    if hookenv.hook_name() != 'update-status':
-        hookenv.status_set('blocked', 'Missing relations: nrpe')
+    """Avoid a user action to be missed or overwritten by another hook"""
+    if hookenv.hook_name() != "update-status":
+        hookenv.status_set("blocked", "Missing relations: nrpe")
 
 
-@when('openstack-service-checks.installed')
-@when('nrpe-external-master.available')
+@when("openstack-service-checks.installed")
+@when("nrpe-external-master.available")
 def parse_hooks():
-    if hookenv.hook_name() == 'upgrade-charm':
+    if hookenv.hook_name() == "upgrade-charm":
         # Check if creds storage needs to be migrated
         # Old key: keystone-relation-creds
         # New key: keystonecreds
         kv = unitdata.kv()
-        creds = kv.get('keystonecreds')
-        old_creds = kv.get('keystone-relation-creds')
+        creds = kv.get("keystonecreds")
+        old_creds = kv.get("keystone-relation-creds")
         if old_creds and not creds:
             # This set of creds needs an update to a newer format
             creds = {
-                'username': old_creds['credentials_username'],
-                'password': old_creds['credentials_password'],
-                'project_name': old_creds['credentials_project'],
-                'tenant_name': old_creds['credentials_project'],
-                'user_domain_name': old_creds.get('credentials_user_domain'),
-                'project_domain_name': old_creds.get('credentials_project_domain'),
-                }
-            kv.set('keystonecreds', creds)
+                "username": old_creds["credentials_username"],
+                "password": old_creds["credentials_password"],
+                "project_name": old_creds["credentials_project"],
+                "tenant_name": old_creds["credentials_project"],
+                "user_domain_name": old_creds.get("credentials_user_domain"),
+                "project_domain_name": old_creds.get("credentials_project_domain"),
+            }
+            kv.set("keystonecreds", creds)
 
         if old_creds:
-            kv.unset('keystone-relation-creds')
+            kv.unset("keystone-relation-creds")
 
         # update rally check files and plugins, which may have changed
         helper.update_plugins()
         helper.update_rally_checkfiles()
 
         # render configs again
-        clear_flag('openstack-service-checks.configured')
+        clear_flag("openstack-service-checks.configured")
 
 
 def _set_keystone_error_workload_status(keystone_error):
-    error_status_message = 'Failed to create endpoint checks due issue communicating with Keystone'
-    hookenv.log('{}. Error:\n{}'.format(error_status_message, keystone_error), level=hookenv.ERROR)
-    hookenv.status_set('blocked', keystone_error.workload_status)
+    error_status_message = (
+        "Failed to create endpoint checks due issue communicating with Keystone"
+    )
+    hookenv.log(
+        "{}. Error:\n{}".format(error_status_message, keystone_error),
+        level=hookenv.ERROR,
+    )
+    hookenv.status_set("blocked", keystone_error.workload_status)
diff --git a/src/tests/functional/conftest.py b/src/tests/functional/conftest.py
index 41b4b5f..948059b 100644
--- a/src/tests/functional/conftest.py
+++ b/src/tests/functional/conftest.py
@@ -1,4 +1,4 @@
-'''
+"""
 Reusable pytest fixtures for functional testing
 
 Environment variables
@@ -6,7 +6,7 @@ Environment variables
 
 test_preserve_model:
 if set, the testing model won't be torn down at the end of the testing session
-'''
+"""
 
 import asyncio
 import json
@@ -19,7 +19,7 @@ import juju
 from juju.controller import Controller
 from juju.errors import JujuError
 
-STAT_CMD = '''python3 - <<EOF
+STAT_CMD = """python3 - <<EOF
 import json
 import os
 
@@ -34,13 +34,13 @@ stat_json = json.dumps(stat_hash)
 print(stat_json)
 
 EOF
-'''
+"""
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 def event_loop():
-    '''Override the default pytest event loop to allow for fixtures using a
-    broader scope'''
+    """Override the default pytest event loop to allow for fixtures using a
+    broader scope"""
     loop = asyncio.get_event_loop_policy().new_event_loop()
     asyncio.set_event_loop(loop)
     loop.set_debug(True)
@@ -49,37 +49,38 @@ def event_loop():
     asyncio.set_event_loop(None)
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def controller():
-    '''Connect to the current controller'''
+    """Connect to the current controller"""
     _controller = Controller()
     await _controller.connect_current()
     yield _controller
     await _controller.disconnect()
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def model(controller):
-    '''This model lives only for the duration of the test'''
-    model_name = os.getenv('PYTEST_MODEL')
+    """This model lives only for the duration of the test"""
+    model_name = os.getenv("PYTEST_MODEL")
     if model_name is None:
         model_name = "functest-{}".format(str(uuid.uuid4())[-12:])
 
     if model_name not in await controller.list_models():
-        _model = await controller.add_model(model_name,
-                                            cloud_name=os.getenv('PYTEST_CLOUD_NAME'),
-                                            region=os.getenv('PYTEST_CLOUD_REGION'),
-                                            )
+        _model = await controller.add_model(
+            model_name,
+            cloud_name=os.getenv("PYTEST_CLOUD_NAME"),
+            region=os.getenv("PYTEST_CLOUD_REGION"),
+        )
     else:
         _model = await controller.get_model(model_name)
 
     # https://github.com/juju/python-libjuju/issues/267
-    subprocess.check_call(['juju', 'models'])
+    subprocess.check_call(["juju", "models"])
     while model_name not in await controller.list_models():
         await asyncio.sleep(1)
     yield _model
     await _model.disconnect()
-    if not os.getenv('PYTEST_KEEP_MODEL'):
+    if not os.getenv("PYTEST_KEEP_MODEL"):
         await controller.destroy_model(model_name)
         while model_name in await controller.list_models():
             await asyncio.sleep(1)
@@ -87,30 +88,35 @@ async def model(controller):
 
 @pytest.fixture
 async def get_app(model):
-    '''Returns the application requested'''
+    """Returns the application requested"""
+
     async def _get_app(name):
         try:
             return model.applications[name]
         except KeyError:
             raise JujuError("Cannot find application {}".format(name))
+
     return _get_app
 
 
 @pytest.fixture
 async def get_unit(model):
-    '''Returns the requested <app_name>/<unit_number> unit'''
+    """Returns the requested <app_name>/<unit_number> unit"""
+
     async def _get_unit(name):
         try:
-            (app_name, unit_number) = name.split('/')
+            (app_name, unit_number) = name.split("/")
             return model.applications[app_name].units[unit_number]
         except (KeyError, ValueError):
             raise JujuError("Cannot find unit {}".format(name))
+
     return _get_unit
 
 
 @pytest.fixture
 async def get_entity(get_unit, get_app):
-    '''Returns a unit or an application'''
+    """Returns a unit or an application"""
+
     async def _get_entity(name):
         try:
             return await get_unit(name)
@@ -119,63 +125,68 @@ async def get_entity(get_unit, get_app):
                 return await get_app(name)
             except JujuError:
                 raise JujuError("Cannot find entity {}".format(name))
+
     return _get_entity
 
 
 @pytest.fixture
 async def run_command(get_unit):
-    '''
+    """
     Runs a command on a unit.
 
     :param cmd: Command to be run
     :param target: Unit object or unit name string
-    '''
+    """
+
     async def _run_command(cmd, target):
-        unit = (
-            target
-            if isinstance(target, juju.unit.Unit)
-            else await get_unit(target)
-        )
+        unit = target if isinstance(target, juju.unit.Unit) else await get_unit(target)
         action = await unit.run(cmd)
         return action.results
+
     return _run_command
 
 
 @pytest.fixture
 async def file_stat(run_command):
-    '''
+    """
     Runs stat on a file
 
     :param path: File path
     :param target: Unit object or unit name string
-    '''
+    """
+
     async def _file_stat(path, target):
         cmd = STAT_CMD % path
         results = await run_command(cmd, target)
         assert results["Code"] == "0", "Error stat {} on {}: {}".format(
-            path, target, results.get("Stderr", "?"))
-        return json.loads(results['Stdout'])
+            path, target, results.get("Stderr", "?")
+        )
+        return json.loads(results["Stdout"])
+
     return _file_stat
 
 
 @pytest.fixture
 async def file_contents(run_command):
-    '''
+    """
     Returns the contents of a file
 
     :param path: File path
     :param target: Unit object or unit name string
-    '''
+    """
+
     async def _file_contents(path, target):
-        cmd = 'cat {}'.format(path)
+        cmd = "cat {}".format(path)
         results = await run_command(cmd, target)
-        return results['Stdout']
+        return results["Stdout"]
+
     return _file_contents
 
 
 @pytest.fixture
 async def reconfigure_app(get_app, model):
-    '''Applies a different config to the requested app'''
+    """Applies a different config to the requested app"""
+
     async def _reconfigure_app(cfg, target):
         application = (
             target
@@ -184,5 +195,6 @@ async def reconfigure_app(get_app, model):
         )
         await application.set_config(cfg)
         await application.get_config()
-        await model.block_until(lambda: application.status == 'active')
+        await model.block_until(lambda: application.status == "active")
+
     return _reconfigure_app
diff --git a/src/tests/functional/test_deploy.py b/src/tests/functional/test_deploy.py
index c14ff02..e7d5782 100644
--- a/src/tests/functional/test_deploy.py
+++ b/src/tests/functional/test_deploy.py
@@ -7,19 +7,20 @@ import pytest
 pytestmark = pytest.mark.asyncio
 
 SERIES = [
-    'xenial',
-    'bionic',
-    'focal',
+    "xenial",
+    "bionic",
+    "focal",
 ]
-CHARM_BUILD_DIR = os.getenv('CHARM_BUILD_DIR', '.').rstrip('/')
+CHARM_BUILD_DIR = os.getenv("CHARM_BUILD_DIR", ".").rstrip("/")
 
 
 # Custom fixtures
 
[e-mail](scope='module', params=SERIES)
+
[e-mail](scope="module", params=SERIES)
 async def osc_apps(request, model):
     series = request.param
-    app = model.applications.get('openstack-service-checks-{}'.format(series))
+    app = model.applications.get("openstack-service-checks-{}".format(series))
     return app
 
 
@@ -28,15 +29,26 @@ class ActionFailed(Exception):
 
     def __init__(self, action):
         """Set information about action failure in message and raise."""
-        params = {key: getattr(action, key, "<not-set>")
-                  for key in ['name', 'parameters', 'receiver',
-                              'message', 'id', 'status',
-                              'enqueued', 'started', 'completed']}
-        message = ('Run of action "{name}" with parameters "{parameters}" on '
-                   '"{receiver}" failed with "{message}" (id={id} '
-                   'status={status} enqueued={enqueued} started={started} '
-                   'completed={completed})'
-                   .format(**params))
+        params = {
+            key: getattr(action, key, "<not-set>")
+            for key in [
+                "name",
+                "parameters",
+                "receiver",
+                "message",
+                "id",
+                "status",
+                "enqueued",
+                "started",
+                "completed",
+            ]
+        }
+        message = (
+            'Run of action "{name}" with parameters "{parameters}" on '
+            '"{receiver}" failed with "{message}" (id={id} '
+            "status={status} enqueued={enqueued} started={started} "
+            "completed={completed})".format(**params)
+        )
         super(ActionFailed, self).__init__(message)
 
 
@@ -47,18 +59,17 @@ class Agent:
     async def _act(self, action, **kwargs):
         action_obj = await self.unit.run_action(action, **kwargs)
         await action_obj.wait()
-        if action_obj.status != 'completed':
+        if action_obj.status != "completed":
             raise ActionFailed(action_obj)
 
     def status(self, status):
-        return (self.unit.workload_status == status and
-                self.unit.agent_status == 'idle')
+        return self.unit.workload_status == status and self.unit.agent_status == "idle"
 
     async def pause(self):
-        await self._act('pause')
+        await self._act("pause")
 
     async def resume(self):
-        await self._act('resume')
+        await self._act("resume")
 
     async def block_until(self, lambda_f, timeout=600, wait_period=1):
         await self.unit.model.block_until(
@@ -68,21 +79,28 @@ class Agent:
 
 def app_names(series=None):
     apps = {
-        app: app for app in
-        ['keystone', 'neutron-api', 'nova-cloud-controller',
-         'percona-cluster', 'rabbitmq-server', 'nagios', 'ceph-radosgw']
+        app: app
+        for app in [
+            "keystone",
+            "neutron-api",
+            "nova-cloud-controller",
+            "percona-cluster",
+            "rabbitmq-server",
+            "nagios",
+            "ceph-radosgw",
+        ]
     }
     if not series:
         return apps
 
-    for app in ['openstack-service-checks', 'nrpe']:
-        apps[app] = '{}-{}'.format(app, series)
+    for app in ["openstack-service-checks", "nrpe"]:
+        apps[app] = "{}-{}".format(app, series)
     return apps
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def deploy_openstack(model):
-    blocking_apps = {'nova-cloud-controller', 'ceph-radosgw'}
+    blocking_apps = {"nova-cloud-controller", "ceph-radosgw"}
     apps = app_names()
     active_apps = []
     is_deployed = False
@@ -92,8 +110,9 @@ async def deploy_openstack(model):
                 active_apps.append(model.applications[app])
             is_deployed = True
             continue
-        app_deploy = await model.deploy('cs:{}'.format(app), series='bionic',
-                                        application_name=app, num_units=1)
+        app_deploy = await model.deploy(
+            "cs:{}".format(app), series="bionic", application_name=app, num_units=1
+        )
         if app not in blocking_apps:
             # we don't expect blocking apps to become active as we don't
             # configure them fully for this test
@@ -103,49 +122,71 @@ async def deploy_openstack(model):
         yield active_apps
         return
 
-    await model.add_relation('{}:shared-db'.format(apps['keystone']),
-                             '{}:shared-db'.format(apps['percona-cluster']))
+    await model.add_relation(
+        "{}:shared-db".format(apps["keystone"]),
+        "{}:shared-db".format(apps["percona-cluster"]),
+    )
 
-    for app in 'neutron-api nova-cloud-controller'.split():
+    for app in "neutron-api nova-cloud-controller".split():
         # Note(aluria): Both neutron/nova APIs needs rmq, mysql, keystone
-        await model.add_relation('{}:amqp'.format(apps[app]),
-                                 '{}:amqp'.format(apps['rabbitmq-server']))
-        await model.add_relation('{}:shared-db'.format(apps[app]),
-                                 '{}:shared-db'.format(apps['percona-cluster']))
-        await model.add_relation('{}:identity-service'.format(apps[app]),
-                                 '{}:identity-service'.format(apps['keystone']))
-    await model.add_relation('{}:identity-service'.format(apps['ceph-radosgw']),
-                             '{}:identity-service'.format(apps['keystone']))
+        await model.add_relation(
+            "{}:amqp".format(apps[app]), "{}:amqp".format(apps["rabbitmq-server"])
+        )
+        await model.add_relation(
+            "{}:shared-db".format(apps[app]),
+            "{}:shared-db".format(apps["percona-cluster"]),
+        )
+        await model.add_relation(
+            "{}:identity-service".format(apps[app]),
+            "{}:identity-service".format(apps["keystone"]),
+        )
+    await model.add_relation(
+        "{}:identity-service".format(apps["ceph-radosgw"]),
+        "{}:identity-service".format(apps["keystone"]),
+    )
     yield active_apps
 
 
[e-mail](scope='module', params=SERIES)
[e-mail](scope="module", params=SERIES)
 async def deploy_app(request, deploy_openstack, model):
-    await model.block_until(lambda: all([app.status == 'active' for app in deploy_openstack]),
-                            timeout=1200)
+    await model.block_until(
+        lambda: all([app.status == "active" for app in deploy_openstack]), timeout=1200
+    )
     series = request.param
     apps = app_names(series)
 
     # Starts a deploy for each series
-    if (apps['nrpe'] in model.applications
-            and apps['openstack-service-checks'] in model.applications):
-        yield model.applications[apps['openstack-service-checks']]
+    if (
+        apps["nrpe"] in model.applications
+        and apps["openstack-service-checks"] in model.applications
+    ):
+        yield model.applications[apps["openstack-service-checks"]]
         return
 
-    await model.deploy('cs:nrpe', series=series, application_name=apps['nrpe'], num_units=0)
-    osc_app = await model.deploy(os.path.join(CHARM_BUILD_DIR, 'openstack-service-checks'),
-                                 series=series, application_name=apps['openstack-service-checks'])
+    await model.deploy(
+        "cs:nrpe", series=series, application_name=apps["nrpe"], num_units=0
+    )
+    osc_app = await model.deploy(
+        os.path.join(CHARM_BUILD_DIR, "openstack-service-checks"),
+        series=series,
+        application_name=apps["openstack-service-checks"],
+    )
 
     # Add relations: nagios/nrpe, keystone/osc, nrpe/osc
-    await model.add_relation('{}:monitors'.format(apps['nrpe']),
-                             '{}:monitors'.format(apps['nagios']))
-    await model.add_relation(apps['nrpe'], apps['openstack-service-checks'])
+    await model.add_relation(
+        "{}:monitors".format(apps["nrpe"]), "{}:monitors".format(apps["nagios"])
+    )
+    await model.add_relation(apps["nrpe"], apps["openstack-service-checks"])
     credrel = "{}:identity-credentials"
-    await model.add_relation(credrel.format(apps['keystone']),
-                             credrel.format(apps['openstack-service-checks']))
+    await model.add_relation(
+        credrel.format(apps["keystone"]),
+        credrel.format(apps["openstack-service-checks"]),
+    )
     notifrel = "{}:identity-notifications"
-    await model.add_relation(notifrel.format(apps['keystone']),
-                             notifrel.format(apps['openstack-service-checks']))
+    await model.add_relation(
+        notifrel.format(apps["keystone"]),
+        notifrel.format(apps["openstack-service-checks"]),
+    )
     yield osc_app
 
 
@@ -157,107 +198,142 @@ def unit_from(model, name):
 
 # Tests
 async def test_openstackservicechecks_deploy_openstack(deploy_openstack, model):
-    await model.block_until(lambda: all([app.status == 'active' for app in deploy_openstack]),
-                            timeout=1200)
+    await model.block_until(
+        lambda: all([app.status == "active" for app in deploy_openstack]), timeout=1200
+    )
 
 
 async def test_openstackservicechecks_deploy(deploy_app, model):
-    await model.block_until(lambda: deploy_app.status == 'active', timeout=1200)
+    await model.block_until(lambda: deploy_app.status == "active", timeout=1200)
 
 
-async def test_openstackservicechecks_verify_default_nrpe_checks(deploy_app, model, file_stat):
+async def test_openstackservicechecks_verify_default_nrpe_checks(
+    deploy_app, model, file_stat
+):
     unit = unit_from(model, deploy_app.name)
-    endpoint_checks_config = ['check_{endpoint}_urls'.format(endpoint=endpoint)
-                              for endpoint in 'admin internal public'.split()]
+    endpoint_checks_config = [
+        "check_{endpoint}_urls".format(endpoint=endpoint)
+        for endpoint in "admin internal public".split()
+    ]
     await deploy_app.reset_config(endpoint_checks_config)
     # Wait until nrpe checks are created
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600)
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+    )
     filenames = [
-        '/etc/nagios/nrpe.d/check_{service}_{endpoint}.cfg'.format(service=service, endpoint=endpoint)
-        for service in 'keystone neutron nova placement swift'.split()
-        for endpoint in 'admin internal public'.split()
+        "/etc/nagios/nrpe.d/check_{service}_{endpoint}.cfg".format(
+            service=service, endpoint=endpoint
+        )
+        for service in "keystone neutron nova placement swift".split()
+        for endpoint in "admin internal public".split()
     ]
-    filenames.extend([
-        '/etc/nagios/nrpe.d/check_cinder_services.cfg',
-        '/etc/nagios/nrpe.d/check_neutron_agents.cfg',
-        '/etc/nagios/nrpe.d/check_nova_services.cfg',
-    ])
+    filenames.extend(
+        [
+            "/etc/nagios/nrpe.d/check_cinder_services.cfg",
+            "/etc/nagios/nrpe.d/check_neutron_agents.cfg",
+            "/etc/nagios/nrpe.d/check_nova_services.cfg",
+        ]
+    )
     for filename in filenames:
         test_stat = await file_stat(filename, unit)
-        assert test_stat['size'] > 0
+        assert test_stat["size"] > 0
 
 
 async def test_openstackservicechecks_update_endpoint(deploy_app, model, file_stat):
     unit = unit_from(model, deploy_app.name)
-    keystone = model.applications['keystone']
+    keystone = model.applications["keystone"]
     assert len(keystone.units) == 1
     kst_unit = keystone.units[0]
-    rgw = model.applications['ceph-radosgw']
+    rgw = model.applications["ceph-radosgw"]
     assert len(rgw.units) == 1
-    expect_port = '8080'
-    await rgw.set_config({'port': expect_port})
+    expect_port = "8080"
+    await rgw.set_config({"port": expect_port})
     # avoid jumping over the config change (test script faster than Juju controller)
     await asyncio.sleep(2)
-    await model.block_until(lambda: rgw.units[0].agent_status == 'idle',
-                            timeout=600, wait_period=1)
-    await model.block_until(lambda: keystone.status == 'active' and kst_unit.agent_status == 'idle',
-                            timeout=600, wait_period=1)
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600, wait_period=1)
+    await model.block_until(
+        lambda: rgw.units[0].agent_status == "idle", timeout=600, wait_period=1
+    )
+    await model.block_until(
+        lambda: keystone.status == "active" and kst_unit.agent_status == "idle",
+        timeout=600,
+        wait_period=1,
+    )
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+        wait_period=1,
+    )
     for _ in range(10):
         # Need to retry this as endpoint update takes some time to propagate
         check_configs = []
-        for endpoint in 'admin internal public'.split():
-            filename = '/etc/nagios/nrpe.d/check_swift_{}.cfg'.format(endpoint)
-            action = await unit.run('cat {}'.format(filename))
+        for endpoint in "admin internal public".split():
+            filename = "/etc/nagios/nrpe.d/check_swift_{}.cfg".format(endpoint)
+            action = await unit.run("cat {}".format(filename))
             result = action.results
-            assert result["Code"] == "0", "Error {}: {}".format(filename, result["Stderr"])
+            assert result["Code"] == "0", "Error {}: {}".format(
+                filename, result["Stderr"]
+            )
             check_configs.append(result["Stdout"])
         if all([" -p {} ".format(expect_port) in s for s in check_configs]):
             break
         await asyncio.sleep(4)
     else:
         assert False, "Port {} not in all endpoints: {}".format(
-            expect_port, check_configs)
+            expect_port, check_configs
+        )
 
 
-async def test_openstackservicechecks_remove_endpoint_checks(deploy_app, model, file_stat):
+async def test_openstackservicechecks_remove_endpoint_checks(
+    deploy_app, model, file_stat
+):
     unit = unit_from(model, deploy_app.name)
-    endpoint_checks_config = {'check_{endpoint}_urls'.format(endpoint=endpoint): 'false'
-                              for endpoint in 'admin internal public'.split()}
+    endpoint_checks_config = {
+        "check_{endpoint}_urls".format(endpoint=endpoint): "false"
+        for endpoint in "admin internal public".split()
+    }
     await deploy_app.set_config(endpoint_checks_config)
     # Wait until nrpe checks are removed
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600)
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+    )
     filenames = [
-        '/etc/nagios/nrpe.d/check_{service}_{endpoint}.cfg'.format(service=service, endpoint=endpoint)
-        for service in 'keystone neutron nova placement'.split()
-        for endpoint in 'admin internal public'.split()
+        "/etc/nagios/nrpe.d/check_{service}_{endpoint}.cfg".format(
+            service=service, endpoint=endpoint
+        )
+        for service in "keystone neutron nova placement".split()
+        for endpoint in "admin internal public".split()
     ]
     for filename in filenames:
         # raises exception because filename does not exist
         with pytest.raises(AssertionError):
             await file_stat(filename, unit)
     # re-enable endpoint checks
-    endpoint_checks_config = ['check_{endpoint}_urls'.format(endpoint=endpoint)
-                              for endpoint in 'admin internal public'.split()]
+    endpoint_checks_config = [
+        "check_{endpoint}_urls".format(endpoint=endpoint)
+        for endpoint in "admin internal public".split()
+    ]
     await deploy_app.reset_config(endpoint_checks_config)
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600)
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+    )
 
 
 async def test_openstackservicechecks_enable_rally(deploy_app, model, file_stat):
     unit = unit_from(model, deploy_app.name)
-    filenames = ['/etc/cron.d/osc_rally', '/etc/nagios/nrpe.d/check_rally.cfg']
+    filenames = ["/etc/cron.d/osc_rally", "/etc/nagios/nrpe.d/check_rally.cfg"]
 
     # disable rally nrpe check if it was enabled (ie. from a previous run of functests)
     config = await deploy_app.get_config()
-    if config['check-rally']['value']:
-        await deploy_app.set_config({'check-rally': 'false'})
+    if config["check-rally"]["value"]:
+        await deploy_app.set_config({"check-rally": "false"})
         # Wait until nrpe check is set
-        await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                                timeout=600)
+        await model.block_until(
+            lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+            timeout=600,
+        )
 
     # Check BEFORE enabling check-rally
     for filename in filenames:
@@ -265,116 +341,140 @@ async def test_openstackservicechecks_enable_rally(deploy_app, model, file_stat)
         with pytest.raises(AssertionError):
             await file_stat(filename, unit)
 
-    await deploy_app.set_config({'check-rally': 'true'})
+    await deploy_app.set_config({"check-rally": "true"})
     # Wait until nrpe check is set
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600)
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+    )
 
     # Check AFTER enabling check-rally
     for filename in filenames:
         test_stat = await file_stat(filename, unit)
-        assert test_stat['size'] > 0
+        assert test_stat["size"] > 0
 
 
-async def test_openstackservicechecks_enable_contrail_analytics_vip(deploy_app, model, file_stat, file_contents):
+async def test_openstackservicechecks_enable_contrail_analytics_vip(
+    deploy_app, model, file_stat, file_contents
+):
     unit = unit_from(model, deploy_app.name)
-    filename = '/etc/nagios/nrpe.d/check_contrail_analytics_alarms.cfg'
+    filename = "/etc/nagios/nrpe.d/check_contrail_analytics_alarms.cfg"
 
     # disable contrail nrpe check if it was enabled
     # (ie. from a previous run of functests)
     config = await deploy_app.get_config()
-    if config['contrail_analytics_vip']['value']:
-        await deploy_app.set_config({'contrail_analytics_vip': ''})
+    if config["contrail_analytics_vip"]["value"]:
+        await deploy_app.set_config({"contrail_analytics_vip": ""})
         # Wait until nrpe check is set
-        await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                                timeout=600)
+        await model.block_until(
+            lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+            timeout=600,
+        )
 
     # Check BEFORE enabling contrail_analytics_vip
     # raises exception because filename does not exist
     with pytest.raises(AssertionError):
         await file_stat(filename, unit)
 
-    await deploy_app.set_config({
-        'contrail_analytics_vip': '127.0.0.1',
-        'contrail_ignored_alarms': 'vrouter,testable'
-    })
+    await deploy_app.set_config(
+        {
+            "contrail_analytics_vip": "127.0.0.1",
+            "contrail_ignored_alarms": "vrouter,testable",
+        }
+    )
     # Wait until nrpe check is set
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600)
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+    )
 
     # Check AFTER enabling contrail_analytics_vip
     test_stat = await file_stat(filename, unit)
-    assert test_stat['size'] > 0
+    assert test_stat["size"] > 0
 
     # Get Contents after enabling contrail_analytics_vip
     test_content = await file_contents(filename, unit)
     assert "--ignored vrouter,testable" in test_content
 
 
-async def test_openstackservicechecks_disable_check_neutron_agents(deploy_app, model, file_stat):
+async def test_openstackservicechecks_disable_check_neutron_agents(
+    deploy_app, model, file_stat
+):
     unit = unit_from(model, deploy_app.name)
-    filename = '/etc/nagios/nrpe.d/check_neutron_agents.cfg'
+    filename = "/etc/nagios/nrpe.d/check_neutron_agents.cfg"
 
-    # disable neutron_agents nrpe check if it was enabled (ie. from a previous run of functests)
+    # disable neutron_agents nrpe check if it was enabled
+    # i.e. from a previous run of functests
     config = await deploy_app.get_config()
-    if config['check-neutron-agents']['value']:
-        await deploy_app.set_config({'check-neutron-agents': 'false'})
+    if config["check-neutron-agents"]["value"]:
+        await deploy_app.set_config({"check-neutron-agents": "false"})
         # Wait until nrpe check is set
-        await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                                timeout=600)
+        await model.block_until(
+            lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+            timeout=600,
+        )
 
     # Check BEFORE enabling neutron_agents check
     # raises exception because filename does not exist
     with pytest.raises(AssertionError):
         await file_stat(filename, unit)
 
-    await deploy_app.set_config({'check-neutron-agents': 'true'})
+    await deploy_app.set_config({"check-neutron-agents": "true"})
     # Wait until nrpe check is set
-    await model.block_until(lambda: deploy_app.status == 'active' and unit.agent_status == 'idle',
-                            timeout=600)
+    await model.block_until(
+        lambda: deploy_app.status == "active" and unit.agent_status == "idle",
+        timeout=600,
+    )
 
     # Check AFTER enabling neutron_agents check
     test_stat = await file_stat(filename, unit)
-    assert test_stat['size'] > 0
+    assert test_stat["size"] > 0
 
 
[e-mail](scope='module')
[e-mail](scope="module")
 async def paused_keystone(deploy_app, deploy_openstack, model):
-    await model.block_until(lambda: all([app.status == 'active' for app in deploy_openstack]),
-                            timeout=1200)
-    keystone = model.applications['keystone']
-    agent = Agent(unit_from(model, 'keystone'))
+    await model.block_until(
+        lambda: all([app.status == "active" for app in deploy_openstack]), timeout=1200
+    )
+    keystone = model.applications["keystone"]
+    agent = Agent(unit_from(model, "keystone"))
 
     # get default port
     kst_cfg = await keystone.get_config()
-    default_port = kst_cfg['service-port'].get('value') or kst_cfg['service-port'].get('default')
+    default_port = kst_cfg["service-port"].get("value") or kst_cfg["service-port"].get(
+        "default"
+    )
     new_svc_port = int(default_port) + 1
 
     # adjust keystone config service-port
-    await keystone.set_config({'service-port': str(new_svc_port)})
-    await agent.block_until(lambda: agent.status('active'))
+    await keystone.set_config({"service-port": str(new_svc_port)})
+    await agent.block_until(lambda: agent.status("active"))
 
     # pause keystone
     await agent.pause()
-    await agent.block_until(lambda: agent.status('maintenance'))
+    await agent.block_until(lambda: agent.status("maintenance"))
 
     yield keystone
 
     # resume keystone
     await agent.resume()
-    await agent.block_until(lambda: agent.status('active'))
+    await agent.block_until(lambda: agent.status("active"))
 
     # restore service-port
-    await keystone.set_config({'service-port': str(default_port)})
-    await agent.block_until(lambda: agent.status('active'))
+    await keystone.set_config({"service-port": str(default_port)})
+    await agent.block_until(lambda: agent.status("active"))
 
 
 @pytest.mark.usefixtures("paused_keystone")
-async def test_openstackservicechecks_invalid_keystone_workload_status(model, deploy_app):
+async def test_openstackservicechecks_invalid_keystone_workload_status(
+    model, deploy_app
+):
     agent = Agent(unit_from(model, deploy_app.name))
 
     # Wait for osc app to block with expected workload-status
-    await agent.block_until(lambda: agent.status('blocked'))
-    assert agent.unit.workload_status_message == \
-        'Keystone server error was encountered trying to list keystone ' \
-        'resources. Check keystone server health. View juju logs for more info.'
+    await agent.block_until(lambda: agent.status("blocked"))
+    assert (
+        agent.unit.workload_status_message
+        == "Keystone server error was encountered trying to list keystone "
+        "resources. Check keystone server health. View juju logs for more info."
+    )
diff --git a/src/tests/nagios_plugin/setup.py b/src/tests/nagios_plugin/setup.py
index e0301bb..90f14d5 100644
--- a/src/tests/nagios_plugin/setup.py
+++ b/src/tests/nagios_plugin/setup.py
@@ -5,36 +5,36 @@ import urllib.request
 
 
 with TemporaryDirectory() as tempd:
-    URL = 'https://git.launchpad.net/nrpe-charm/plain/files/nagios_plugin3.py'
+    URL = "https://git.launchpad.net/nrpe-charm/plain/files/nagios_plugin3.py"
     script = os.path.join(tempd, os.path.basename(URL))
-    with open(script, 'wb') as dest_f:
+    with open(script, "wb") as dest_f:
         print("downloading {}".format(URL))
         dest_f.write(urllib.request.urlopen(URL).read())
         print("writing {}".format(script))
     setup(
-        name='nagios_plugin3',
-        description='nagios plugin from the NRPE charm',
+        name="nagios_plugin3",
+        description="nagios plugin from the NRPE charm",
         download_url=URL,
         project_urls={
-            'nrpe source': 'https://git.launchpad.net/nrpe-charm/',
-            'nrpe issues': 'https://bugs.launchpad.net/charm-nrpe',
+            "nrpe source": "https://git.launchpad.net/nrpe-charm/",
+            "nrpe issues": "https://bugs.launchpad.net/charm-nrpe",
         },
         classifiers=[
-            'Environment :: Plugins',
-            'Intended Audience :: Developers',
-            'Intended Audience :: System Administrators',
-            'Operating System :: POSIX',
-            'Programming Language :: Python :: 2.7',
-            'Programming Language :: Python :: 3.4',
-            'Programming Language :: Python :: 3.5',
-            'Programming Language :: Python :: 3.6',
-            'Programming Language :: Python :: 3.7',
-            'Topic :: Software Development :: Libraries :: Python Modules',
-            'Topic :: System :: Monitoring',
+            "Environment :: Plugins",
+            "Intended Audience :: Developers",
+            "Intended Audience :: System Administrators",
+            "Operating System :: POSIX",
+            "Programming Language :: Python :: 2.7",
+            "Programming Language :: Python :: 3.4",
+            "Programming Language :: Python :: 3.5",
+            "Programming Language :: Python :: 3.6",
+            "Programming Language :: Python :: 3.7",
+            "Topic :: Software Development :: Libraries :: Python Modules",
+            "Topic :: System :: Monitoring",
         ],
-        keywords='nrpe nagios plugin check monitoring',
-        author='Llama Charmers',
-        author_email='[e-mail] ',
-        package_dir={'': tempd},
-        packages=['']
+        keywords="nrpe nagios plugin check monitoring",
+        author="Llama Charmers",
+        author_email="[e-mail] ",
+        package_dir={"": tempd},
+        packages=[""],
     )
diff --git a/src/tests/unit/conftest.py b/src/tests/unit/conftest.py
index 9266259..e379711 100644
--- a/src/tests/unit/conftest.py
+++ b/src/tests/unit/conftest.py
@@ -7,7 +7,7 @@ import pytest
 TEST_DIR = dirname(abspath(__file__))
 REACTIVE_DIR = dirname(dirname(TEST_DIR))
 CHARM_DIR = REACTIVE_DIR
-CHECKS_DIR = join(CHARM_DIR, 'files', 'plugins')
+CHECKS_DIR = join(CHARM_DIR, "files", "plugins")
 sys.path.append(CHECKS_DIR)
 
 
@@ -16,19 +16,20 @@ sys.path.append(CHECKS_DIR)
 @pytest.fixture
 def mock_layers(monkeypatch):
     import sys
-    sys.modules['charms.layer'] = mock.Mock()
-    sys.modules['reactive'] = mock.Mock()
+
+    sys.modules["charms.layer"] = mock.Mock()
+    sys.modules["reactive"] = mock.Mock()
     # Mock any functions in layers that need to be mocked here
 
     def options(layer):
         # mock options for layers here
-        if layer == 'example-layer':
-            options = {'port': 9999}
+        if layer == "example-layer":
+            options = {"port": 9999}
             return options
         else:
             return None
 
-    monkeypatch.setattr('lib_openstack_service_checks.layer.options', options)
+    monkeypatch.setattr("lib_openstack_service_checks.layer.options", options)
 
 
 @pytest.fixture
@@ -37,49 +38,58 @@ def mock_hookenv_config(monkeypatch):
 
     def mock_config():
         cfg = {}
-        yml = yaml.safe_load(open('./config.yaml'))
+        yml = yaml.safe_load(open("./config.yaml"))
 
         # Load all defaults
-        for key, value in yml['options'].items():
-            cfg[key] = value['default']
+        for key, value in yml["options"].items():
+            cfg[key] = value["default"]
 
         # Manually add cfg from other layers
         # cfg['my-other-layer'] = 'mock'
         return cfg
 
-    monkeypatch.setattr('lib_openstack_service_checks.hookenv.config', mock_config)
+    monkeypatch.setattr("lib_openstack_service_checks.hookenv.config", mock_config)
 
 
 @pytest.fixture
 def mock_remote_unit(monkeypatch):
-    monkeypatch.setattr('lib_openstack_service_checks.hookenv.remote_unit', lambda: 'unit-mock/0')
+    monkeypatch.setattr(
+        "lib_openstack_service_checks.hookenv.remote_unit", lambda: "unit-mock/0"
+    )
 
 
 @pytest.fixture
 def mock_charm_dir(monkeypatch):
-    monkeypatch.setattr('lib_openstack_service_checks.hookenv.charm_dir', lambda: '/mock/charm/dir')
+    monkeypatch.setattr(
+        "lib_openstack_service_checks.hookenv.charm_dir", lambda: "/mock/charm/dir"
+    )
 
 
 @pytest.fixture
 def mock_unitdata_keystonecreds(monkeypatch):
-    creds = {'keystonecreds': {'username': 'nagios',
-                               'password': 'password',
-                               'project_name': 'services',
-                               'tenant_name': 'services',
-                               'user_domain_name': 'service_domain',
-                               'project_domain_name': 'service_domain',
-                               }
-             }
-    monkeypatch.setattr('lib_openstack_service_checks.unitdata.kv', lambda: creds)
+    creds = {
+        "keystonecreds": {
+            "username": "nagios",
+            "password": "password",
+            "project_name": "services",
+            "tenant_name": "services",
+            "user_domain_name": "service_domain",
+            "project_domain_name": "service_domain",
+        }
+    }
+    monkeypatch.setattr("lib_openstack_service_checks.unitdata.kv", lambda: creds)
 
 
 @pytest.fixture
 def openstackservicechecks(tmpdir, mock_hookenv_config, mock_charm_dir, monkeypatch):
     from lib_openstack_service_checks import OSCHelper
+
     helper = OSCHelper()
 
     # Any other functions that load helper will get this version
-    monkeypatch.setattr('lib_openstack_service_checks.hookenv.log', lambda msg, level='INFO': None)
-    monkeypatch.setattr('lib_openstack_service_checks.OSCHelper', lambda: helper)
+    monkeypatch.setattr(
+        "lib_openstack_service_checks.hookenv.log", lambda msg, level="INFO": None
+    )
+    monkeypatch.setattr("lib_openstack_service_checks.OSCHelper", lambda: helper)
 
     return helper
diff --git a/src/tests/unit/test_check_contrail_analytics_alarms.py b/src/tests/unit/test_check_contrail_analytics_alarms.py
index d397bc9..663814a 100644
--- a/src/tests/unit/test_check_contrail_analytics_alarms.py
+++ b/src/tests/unit/test_check_contrail_analytics_alarms.py
@@ -7,10 +7,12 @@ TEST_DIR = dirname(abspath(__file__))
 
 
 def test_parse_contrail_alarms():
-    with open(join(TEST_DIR, 'contrail_alert_data.json')) as f:
+    with open(join(TEST_DIR, "contrail_alert_data.json")) as f:
         data = json.load(f)
     parsed = check_contrail_analytics_alarms.parse_contrail_alarms(data)
-    assert parsed in """
+    assert (
+        parsed
+        in """
 CRITICAL: total_alarms[11], unacked_or_sev_gt_0[10], total_ignored[0], ignoring r''
 CRITICAL: vrouter{compute-10.maas, sev=1, ts[2020-06-25 18:29:23.149146]} Vrouter interface(s) down.
 WARNING: control-node{control-8-contrail-rmq, sev=0, ts[2020-06-25 18:29:23.684803]} Node Failure. NodeStatus UVE not present.
@@ -23,46 +25,67 @@ CRITICAL: control-node{control-9.maas, sev=1, ts[2020-06-25 18:29:25.183842]} BG
 CRITICAL: vrouter{compute-3.maas, sev=1, ts[2020-06-26 12:20:58.955855]} Vrouter interface(s) down.
 CRITICAL: vrouter{compute-1.maas, sev=1, ts[2020-06-29 13:01:53.459050]} Vrouter interface(s) down.
 CRITICAL: vrouter{compute-7.maas, sev=1, ts[2020-07-03 18:30:32.481386]} Vrouter interface(s) down.
-""" # noqa: ignore=F501
+"""  # noqa:E501
+    )
 
 
 def test_parse_contrail_alarms_filter_vrouter_control_9():
-    with open(join(TEST_DIR, 'contrail_alert_data.json')) as f:
+    with open(join(TEST_DIR, "contrail_alert_data.json")) as f:
         data = json.load(f)
-    ignored_re = r'(?:vrouter)|(?:control-9)'
-    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(data, ignored=ignored_re)
-    assert parsed in """ 
+    ignored_re = r"(?:vrouter)|(?:control-9)"
+    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(
+        data, ignored=ignored_re
+    )
+    assert (
+        parsed
+        in """
 CRITICAL: total_alarms[11], unacked_or_sev_gt_0[10], total_ignored[8], ignoring r'(?:vrouter)|(?:control-9)'
 WARNING: control-node{control-8-contrail-rmq, sev=0, ts[2020-06-25 18:29:23.684803]} Node Failure. NodeStatus UVE not present.
 CRITICAL: control-node{control-8.maas, sev=1, ts[2020-06-25 18:29:24.293341]} BGP peer mismatch. Not enough BGP peers are up.
 CRITICAL: control-node{control-7-contrail-rmq, sev=1, ts[2020-06-25 18:29:24.377040]} BGP peer mismatch. Not enough BGP peers are up.
-""" # noqa: ignore=F501
+"""  # noqa:E501
+    )
 
 
 def test_parse_contrail_alarms_filter_critical():
-    with open(join(TEST_DIR, 'contrail_alert_data.json')) as f:
+    with open(join(TEST_DIR, "contrail_alert_data.json")) as f:
         data = json.load(f)
-    ignored_re = r'(?:CRITICAL)'
-    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(data, ignored=ignored_re)
-    assert parsed in """
+    ignored_re = r"(?:CRITICAL)"
+    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(
+        data, ignored=ignored_re
+    )
+    assert (
+        parsed
+        in """
 WARNING: total_alarms[11], unacked_or_sev_gt_0[10], total_ignored[10], ignoring r'(?:CRITICAL)'
 WARNING: control-node{control-8-contrail-rmq, sev=0, ts[2020-06-25 18:29:23.684803]} Node Failure. NodeStatus UVE not present.
-""" # noqa: ignore=F501
+"""  # noqa: E501
+    )
 
 
 def test_parse_contrail_alarms_all_ignored():
-    with open(join(TEST_DIR, 'contrail_alert_data.json')) as f:
+    with open(join(TEST_DIR, "contrail_alert_data.json")) as f:
         data = json.load(f)
-    ignored_re = r'(?:CRITICAL)|(?:WARNING)'
-    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(data, ignored=ignored_re)
-    assert parsed in """
+    ignored_re = r"(?:CRITICAL)|(?:WARNING)"
+    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(
+        data, ignored=ignored_re
+    )
+    assert (
+        parsed
+        in """
 OK: total_alarms[11], unacked_or_sev_gt_0[10], total_ignored[11], ignoring r'(?:CRITICAL)|(?:WARNING)'
-""" # noqa: ignore=F501
+"""  # noqa:E501
+    )
 
 
 def test_parse_contrail_alarms_no_alarms():
-    ignored_re = r''
-    parsed = check_contrail_analytics_alarms.parse_contrail_alarms({}, ignored=ignored_re)
-    assert parsed in """
+    ignored_re = r""
+    parsed = check_contrail_analytics_alarms.parse_contrail_alarms(
+        {}, ignored=ignored_re
+    )
+    assert (
+        parsed
+        in """
 OK: total_alarms[0], unacked_or_sev_gt_0[0], total_ignored[0], ignoring r''
 """
+    )
diff --git a/src/tests/unit/test_check_nova_services.py b/src/tests/unit/test_check_nova_services.py
index dad32a6..816ec73 100644
--- a/src/tests/unit/test_check_nova_services.py
+++ b/src/tests/unit/test_check_nova_services.py
@@ -4,13 +4,15 @@ import nagios_plugin3
 import check_nova_services
 
 
[e-mail]('is_skip_disabled,num_nodes',
-                         [
-                             (True, 5),
-                             (False, 5),
-                             (True, 2),
-                             (False, 2),
-                         ])
[e-mail](
+    "is_skip_disabled,num_nodes",
+    [
+        (True, 5),
+        (False, 5),
+        (True, 2),
+        (False, 2),
+    ],
+)
 def test_check_hosts_up(is_skip_disabled, num_nodes):
     class _TestArgs(object):
         warn = 2
@@ -18,42 +20,46 @@ def test_check_hosts_up(is_skip_disabled, num_nodes):
         skip_disabled = is_skip_disabled
 
     args = _TestArgs()
-    aggregate = '(not-part-of-any-agg)'
+    aggregate = "(not-part-of-any-agg)"
     services_compute = [
-        {u'status': (u'disabled' if id == 0 else u'enabled'),
-         u'binary': u'nova-compute',
-         u'zone': u'nova',
-         u'state': u'up',
-         u'updated_at': u'2019-07-04T09:23:06.000000',
-         u'host': u'juju-3efade-{}'.format(id),
-         u'disabled_reason': None,
-         u'id': id,
-         }
+        {
+            u"status": (u"disabled" if id == 0 else u"enabled"),
+            u"binary": u"nova-compute",
+            u"zone": u"nova",
+            u"state": u"up",
+            u"updated_at": u"2019-07-04T09:23:06.000000",
+            u"host": u"juju-3efade-{}".format(id),
+            u"disabled_reason": None,
+            u"id": id,
+        }
         for id in range(num_nodes)
     ]
-    hosts = [svc['host'] for svc in services_compute]
+    hosts = [svc["host"] for svc in services_compute]
 
-    msg_text = 'Host juju-3efade-0 disabled'
+    msg_text = "Host juju-3efade-0 disabled"
     if num_nodes <= 2:
         # 1 host enabled + 1 host disabled == 1 host alive (<=1)
         status_critical = True
-        msg_text = ('{}, Host Aggregate (not-part-of-any-agg) has 1 hosts alive'
-                    .format(msg_text))
+        msg_text = "{}, Host Aggregate (not-part-of-any-agg) has 1 hosts alive".format(
+            msg_text
+        )
     else:
         # more than args.crit (1) hosts alive (4)
         status_critical = False
 
     expected = {
-        'agg_name': aggregate,
-        'msg_text': msg_text,
-        'critical': status_critical,
-        'warning': not is_skip_disabled or num_nodes <= args.warn,
+        "agg_name": aggregate,
+        "msg_text": msg_text,
+        "critical": status_critical,
+        "warning": not is_skip_disabled or num_nodes <= args.warn,
     }
-    actual = check_nova_services.check_hosts_up(args, aggregate, hosts, services_compute)
+    actual = check_nova_services.check_hosts_up(
+        args, aggregate, hosts, services_compute
+    )
     assert actual == expected
 
 
[e-mail]('is_skip_disabled', [True, False])
[e-mail]("is_skip_disabled", [True, False])
 def test_check_nova_services(is_skip_disabled, monkeypatch):
     class _TestArgs(object):
         warn = 2
@@ -66,34 +72,41 @@ def test_check_nova_services(is_skip_disabled, monkeypatch):
 
     class _TestNovaJson(object):
         def json(cls):
-            return {'aggregates': [],
-                    'services': [
-                        {u'status': (u'disabled' if id == 0 else u'enabled'),
-                         u'binary': u'nova-compute',
-                         u'zone': u'nova',
-                         u'state': u'up',
-                         u'updated_at': u'2019-07-04T09:23:06.000000',
-                         u'host': u'juju-3efade-{}'.format(id),
-                         u'disabled_reason': None,
-                         u'id': id,
-                         }
-                        for id in range(5)]
+            return {
+                "aggregates": [],
+                "services": [
+                    {
+                        u"status": (u"disabled" if id == 0 else u"enabled"),
+                        u"binary": u"nova-compute",
+                        u"zone": u"nova",
+                        u"state": u"up",
+                        u"updated_at": u"2019-07-04T09:23:06.000000",
+                        u"host": u"juju-3efade-{}".format(id),
+                        u"disabled_reason": None,
+                        u"id": id,
                     }
+                    for id in range(5)
+                ],
+            }
 
     args = _TestArgs()
     nova = _TestNova()
     check_hosts_up_expected = {
-        'agg_name': '(not-part-of-any-agg)',
-        'msg_text': 'Host juju-3efade-0 disabled',
-        'critical': False,
-        'warning': not is_skip_disabled,
+        "agg_name": "(not-part-of-any-agg)",
+        "msg_text": "Host juju-3efade-0 disabled",
+        "critical": False,
+        "warning": not is_skip_disabled,
     }
-    monkeypatch.setattr('check_nova_services.check_hosts_up',
-                        lambda args, aggregate, hosts, svcs_compute: check_hosts_up_expected)
+    monkeypatch.setattr(
+        "check_nova_services.check_hosts_up",
+        lambda args, aggregate, hosts, svcs_compute: check_hosts_up_expected,
+    )
 
     if is_skip_disabled:
         assert check_nova_services.check_nova_services(args, nova) is None
     else:
         with pytest.raises(nagios_plugin3.WarnError) as excinfo:
             check_nova_services.check_nova_services(args, nova)
-        assert str(excinfo.value) == 'WARNING: nova-compute, Host juju-3efade-0 disabled'
+        assert (
+            str(excinfo.value) == "WARNING: nova-compute, Host juju-3efade-0 disabled"
+        )
diff --git a/src/tests/unit/test_check_octavia.py b/src/tests/unit/test_check_octavia.py
index 08c9357..5f871e8 100644
--- a/src/tests/unit/test_check_octavia.py
+++ b/src/tests/unit/test_check_octavia.py
@@ -7,111 +7,128 @@ import check_octavia
 import pytest
 
 
[e-mail]('check_octavia.openstack.connect')
[e-mail]('check', [
-    'loadbalancers', 'pools', "amphorae", "image"
-])
[e-mail]("check_octavia.openstack.connect")
[e-mail]("check", ["loadbalancers", "pools", "amphorae", "image"])
 def test_stable_alarms(connect, check):
     args = mock.MagicMock()
-    args.ignored = r''
+    args.ignored = r""
     args.check = check
     if check == "amphorae":
         # Present 0 Amphora instances
         resp = connect().load_balancer.get()
         resp.status_code = 200
-        resp.content = json.dumps({'amphora': []})
+        resp.content = json.dumps({"amphora": []})
     elif check == "image":
         # Present 1 Active Fresh Amphora image
-        args.amp_image_tag = 'octavia'
+        args.amp_image_tag = "octavia"
         args.amp_image_days = 1
         amp_image = mock.MagicMock()
-        amp_image.status = 'active'
+        amp_image.status = "active"
         amp_image.updated_at = datetime.now().isoformat()
         connect().image.images.return_value = [amp_image]
 
     status, message = check_octavia.process_checks(args)
-    assert message in """
+    assert (
+        message
+        in """
 OK: total_alarms[0], total_crit[0], total_ignored[0], ignoring r''
 """
+    )
     assert status == check_octavia.NAGIOS_STATUS_OK
 
 
[e-mail]('check_octavia.openstack.connect')
[e-mail]("check_octavia.openstack.connect")
 def test_no_images_is_ignorable(connect):
     args = mock.MagicMock()
-    args.ignored = 'none exist'
+    args.ignored = "none exist"
     args.check = "image"
     # Present 1 Active Fresh Amphora image
-    args.amp_image_tag = 'octavia'
+    args.amp_image_tag = "octavia"
     args.amp_image_days = 1
     connect().image.images.return_value = []
 
     status, message = check_octavia.process_checks(args)
-    assert message in """
+    assert (
+        message
+        in """
 OK: total_alarms[1], total_crit[1], total_ignored[1], ignoring r'(?:none exist)'
 """
+    )
     assert status == check_octavia.NAGIOS_STATUS_OK
 
 
[e-mail]('check_octavia.openstack.connect')
[e-mail]("check_octavia.openstack.connect")
 def test_no_images(connect):
     args = mock.MagicMock()
-    args.ignored = r''
+    args.ignored = r""
     args.check = "image"
     # Present 1 Active Fresh Amphora image
-    args.amp_image_tag = 'octavia'
+    args.amp_image_tag = "octavia"
     args.amp_image_days = 1
     connect().image.images.return_value = []
 
     status, message = check_octavia.process_checks(args)
-    assert message in """
+    assert (
+        message
+        in """
 CRITICAL: total_alarms[1], total_crit[1], total_ignored[0], ignoring r''
 Octavia requires image with tag octavia to create amphora, but none exist
 """
+    )
     assert status == check_octavia.NAGIOS_STATUS_CRITICAL
 
 
[e-mail]('check_octavia.openstack.connect')
[e-mail]("check_octavia.openstack.connect")
 def test_no_active_images(connect):
     args = mock.MagicMock()
-    args.ignored = r''
+    args.ignored = r""
     args.check = "image"
     # Present 1 Active Fresh Amphora image
-    args.amp_image_tag = 'octavia'
+    args.amp_image_tag = "octavia"
     args.amp_image_days = 1
     amp_image = mock.MagicMock()
     amp_image.name = "bob-the-image"
     amp_image.id = str(uuid4())
-    amp_image.status = 'inactive'
+    amp_image.status = "inactive"
     amp_image.updated_at = datetime.now().isoformat()
     connect().image.images.return_value = [amp_image]
 
     status, message = check_octavia.process_checks(args)
-    assert message in """
+    assert (
+        message
+        in """
 CRITICAL: total_alarms[1], total_crit[1], total_ignored[0], ignoring r''
 Octavia requires image with tag octavia to create amphora, but none are active: bob-the-image({})
-""".format(amp_image.id)
+""".format(  # noqa:E501
+            amp_image.id
+        )
+    )
     assert status == check_octavia.NAGIOS_STATUS_CRITICAL
 
 
[e-mail]('check_octavia.openstack.connect')
[e-mail]("check_octavia.openstack.connect")
 def test_no_fresh_images(connect):
     args = mock.MagicMock()
-    args.ignored = r''
+    args.ignored = r""
     args.check = "image"
     # Present 1 Active Fresh Amphora image
-    args.amp_image_tag = 'octavia'
+    args.amp_image_tag = "octavia"
     args.amp_image_days = 1
     amp_image = mock.MagicMock()
     amp_image.name = "bob-the-image"
     amp_image.id = str(uuid4())
-    amp_image.status = 'active'
+    amp_image.status = "active"
     amp_image.updated_at = (datetime.now() - timedelta(days=2)).isoformat()
     connect().image.images.return_value = [amp_image]
 
     status, message = check_octavia.process_checks(args)
-    assert message in """
+    assert (
+        message
+        in """
 WARNING: total_alarms[1], total_crit[0], total_ignored[0], ignoring r''
 Octavia requires image with tag octavia to create amphora, but all images are older than 1 day(s): bob-the-image({})
-""".format(amp_image.id)
+""".format(  # noqa:E501
+            amp_image.id
+        )
+    )
     assert status == check_octavia.NAGIOS_STATUS_WARNING
diff --git a/src/tests/unit/test_lib.py b/src/tests/unit/test_lib.py
index 5d4767a..674285d 100644
--- a/src/tests/unit/test_lib.py
+++ b/src/tests/unit/test_lib.py
@@ -3,86 +3,122 @@ from unittest.mock import MagicMock
 import pytest
 import keystoneauth1
 
-from lib_openstack_service_checks import OSCKeystoneServerError, OSCKeystoneClientError, OSCSslError
+from lib_openstack_service_checks import (
+    OSCKeystoneServerError,
+    OSCKeystoneClientError,
+    OSCSslError,
+)
 
 
 def test_openstackservicechecks_common_properties(openstackservicechecks):
-    '''Verify the most common properties from the class or default config.yaml'''
+    """Verify the most common properties from the class or default config.yaml"""
     assert isinstance(openstackservicechecks.charm_config, dict)
-    assert openstackservicechecks.check_dns == ''
-    assert openstackservicechecks.contrail_analytics_vip == ''
+    assert openstackservicechecks.check_dns == ""
+    assert openstackservicechecks.contrail_analytics_vip == ""
     assert openstackservicechecks.is_neutron_agents_check_enabled
     assert not openstackservicechecks.is_rally_enabled
-    assert openstackservicechecks.novarc == '/var/lib/nagios/nagios.novarc'
+    assert openstackservicechecks.novarc == "/var/lib/nagios/nagios.novarc"
     assert openstackservicechecks.nova_crit == 1
     assert openstackservicechecks.nova_warn == 2
-    assert openstackservicechecks.plugins_dir == '/usr/local/lib/nagios/plugins/'
-    assert openstackservicechecks.rally_cron_schedule == '*/15 * * * *'
-    assert openstackservicechecks.skip_disabled == ''
+    assert openstackservicechecks.plugins_dir == "/usr/local/lib/nagios/plugins/"
+    assert openstackservicechecks.rally_cron_schedule == "*/15 * * * *"
+    assert openstackservicechecks.skip_disabled == ""
     assert not openstackservicechecks.skipped_rally_checks
 
 
 def test_openstackservicechecks_get_keystone_credentials_unitdata(
-        openstackservicechecks, mock_unitdata_keystonecreds):
-    """Checks the expected behavior when 'os-credentials' are not shared, but the application is related to keystone.
-    """
+    openstackservicechecks, mock_unitdata_keystonecreds
+):
+    """Check expected behavior when 'os-credentials' not shared, but related to ks."""
     assert openstackservicechecks.get_keystone_credentials() == {
-        'username': 'nagios', 'password': 'password', 'project_name': 'services',
-        'tenant_name': 'services', 'user_domain_name': 'service_domain',
-        'project_domain_name': 'service_domain'
-        }
+        "username": "nagios",
+        "password": "password",
+        "project_name": "services",
+        "tenant_name": "services",
+        "user_domain_name": "service_domain",
+        "project_domain_name": "service_domain",
+    }
 
 
[e-mail]('os_credentials,expected', [
-    (('username=nagios, password=password, region_name=RegionOne, auth_url="http://XX.XX.XX.XX:5000/v3",'
-     'credentials_project=services, domain=service_domain'),
-     {'username': 'nagios', 'password': 'password', 'project_name': 'services', 'auth_version': 3,
-      'user_domain_name': 'service_domain', 'project_domain_name': 'service_domain', 'region_name': 'RegionOne',
-      'auth_url': 'http://XX.XX.XX.XX:5000/v3'},
-     ),
-    (('username=nagios, password=password, region_name=RegionOne, auth_url="http://XX.XX.XX.XX:5000/v2.0",'
-      'credentials_project=services'),
-     {'username': 'nagios', 'password': 'password', 'tenant_name': 'services', 'region_name': 'RegionOne',
-      'auth_url': 'http://XX.XX.XX.XX:5000/v2.0'},
-     )
-])
[e-mail](
+    "os_credentials,expected",
+    [
+        (
+            (
+                'username=nagios, password=password, region_name=RegionOne, auth_url="http://XX.XX.XX.XX:5000/v3",'  # noqa:E501
+                "credentials_project=services, domain=service_domain"
+            ),
+            {
+                "username": "nagios",
+                "password": "password",
+                "project_name": "services",
+                "auth_version": 3,
+                "user_domain_name": "service_domain",
+                "project_domain_name": "service_domain",
+                "region_name": "RegionOne",
+                "auth_url": "http://XX.XX.XX.XX:5000/v3",
+            },
+        ),
+        (
+            (
+                'username=nagios, password=password, region_name=RegionOne, auth_url="http://XX.XX.XX.XX:5000/v2.0",'  # noqa:E501
+                "credentials_project=services"
+            ),
+            {
+                "username": "nagios",
+                "password": "password",
+                "tenant_name": "services",
+                "region_name": "RegionOne",
+                "auth_url": "http://XX.XX.XX.XX:5000/v2.0",
+            },
+        ),
+    ],
+)
 def test_openstackservicechecks_get_keystone_credentials_oscredentials(
-        os_credentials, expected, openstackservicechecks, mock_unitdata_keystonecreds):
-    """Checks the expected behavior when keystone v2 and v3 data is shared via the 'os-credentials' config parameter.
-    """
-    openstackservicechecks.charm_config['os-credentials'] = os_credentials
+    os_credentials, expected, openstackservicechecks, mock_unitdata_keystonecreds
+):
+    """Check the expected behavior when keystone v2 and v3 data is set via config."""
+    openstackservicechecks.charm_config["os-credentials"] = os_credentials
     assert openstackservicechecks.get_os_credentials() == expected
 
 
[e-mail]('skip_rally,result', [
-    ('nova,neutron', [True, True, False, False]),
-    ('cinder,neutron', [False, True, True, False]),
-    ('glance', [True, False, True, True]),
-    ('nova neutron', [True, True, True, True]),  # needs to be comma-separated
-    ('', [True, True, True, True]),
-])
[e-mail](
+    "skip_rally,result",
+    [
+        ("nova,neutron", [True, True, False, False]),
+        ("cinder,neutron", [False, True, True, False]),
+        ("glance", [True, False, True, True]),
+        ("nova neutron", [True, True, True, True]),  # needs to be comma-separated
+        ("", [True, True, True, True]),
+    ],
+)
 def test_get_rally_checks_context(skip_rally, result, openstackservicechecks):
-    openstackservicechecks.charm_config['skip-rally'] = skip_rally
-    expected = {comp: result[num]
-                for num, comp in enumerate('cinder glance nova neutron'.split())}
+    openstackservicechecks.charm_config["skip-rally"] = skip_rally
+    expected = {
+        comp: result[num]
+        for num, comp in enumerate("cinder glance nova neutron".split())
+    }
     assert openstackservicechecks._get_rally_checks_context() == expected
 
 
[e-mail]('keystone_auth_exception,expected_raised_exception', [
-    (keystoneauth1.exceptions.http.InternalServerError, OSCKeystoneServerError),
-    (keystoneauth1.exceptions.connection.ConnectFailure, OSCKeystoneServerError),
-    (keystoneauth1.exceptions.http.BadRequest, OSCKeystoneClientError),
-    (keystoneauth1.exceptions.connection.SSLError, OSCSslError),
-])
[e-mail]('source', ["endpoints", "services"])
[e-mail](
+    "keystone_auth_exception,expected_raised_exception",
+    [
+        (keystoneauth1.exceptions.http.InternalServerError, OSCKeystoneServerError),
+        (keystoneauth1.exceptions.connection.ConnectFailure, OSCKeystoneServerError),
+        (keystoneauth1.exceptions.http.BadRequest, OSCKeystoneClientError),
+        (keystoneauth1.exceptions.connection.SSLError, OSCSslError),
+    ],
+)
[e-mail]("source", ["endpoints", "services"])
 def test_keystone_client_exceptions(
-        keystone_auth_exception, expected_raised_exception,
-        openstackservicechecks, source):
+    keystone_auth_exception, expected_raised_exception, openstackservicechecks, source
+):
     mock_keystone_client = MagicMock()
     getattr(mock_keystone_client, source).list.side_effect = keystone_auth_exception
     openstackservicechecks._keystone_client = mock_keystone_client
     with pytest.raises(expected_raised_exception):
-        if source == 'endpoints':
+        if source == "endpoints":
             openstackservicechecks.keystone_endpoints
         else:
             openstackservicechecks.keystone_services
diff --git a/src/tox.ini b/src/tox.ini
index 4d8ee9d..e00666c 100644
--- a/src/tox.ini
+++ b/src/tox.ini
@@ -25,7 +25,7 @@ passenv =
 [testenv:lint]
 commands =
     flake8
-    #TODO black --check --exclude "/(\.eggs|\.git|\.tox|\.venv|\.build|dist|charmhelpers|mod)/" .
+    black --check --exclude "/(\.eggs|\.git|\.tox|\.venv|\.build|dist|charmhelpers|mod)/" .
 deps =
     black
     flake8
@@ -49,8 +49,7 @@ exclude =
     mod,
     .build
 
-max-line-length = 120
-#TODO max-line-length = 88
+max-line-length = 88
 max-complexity = 10
 
 [testenv:black]