Merge ~barryprice/charm-k8s-wordpress/+git/charm-k8s-wordpress:operator into charm-k8s-wordpress:master

[Barry Price]

Porting to Operator (WIP)

[Tom Haddon (mthaddon)]

Some comments inline

[Barry Price (barryprice)]

Thanks, left some responses and will push fixes for these as well as others.

diff --git a/.gitignore b/.gitignore
 new file mode 100644
index 0000000..172bf57
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.tox
diff --git a/.gitmodules b/.gitmodules
 new file mode 100644
index 0000000..8c05fa9
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "mod/operator"]
+	path = mod/operator
+	url = https://github.com/canonical/operator
diff --git a/Makefile b/Makefile
index a46c2e2..cf18918 100644
--- a/Makefile
+++ b/Makefile
@@ -9,15 +9,8 @@ unittest:
 
 test: lint unittest
 
-build: lint
-	charm build
-
 clean:
 	@echo "Cleaning files"
-	@rm -rf ./.tox
-	@rm -rf ./.pytest_cache
-	@rm -rf ./tests/unit/__pycache__ ./reactive/__pycache__ ./lib/__pycache__
-	@rm -rf ./.coverage ./.unit-state.db
-
+	@git clean -fXd
 
-.PHONY: lint test unittest build clean
+.PHONY: lint test unittest clean
diff --git a/hooks/start b/hooks/start
 new file mode 120000
index 0000000..25b1f68
--- /dev/null
+++ b/hooks/start
@@ -0,0 +1 @@
+../src/charm.py
 \ No newline at end of file
diff --git a/layer.yaml b/layer.yaml
 deleted file mode 100644
index d7700f7..0000000
--- a/layer.yaml
+++ /dev/null
@@ -1,4 +0,0 @@
-includes:
-  - 'layer:caas-base'
-  - 'layer:status'
-repo: git+ssh://git.launchpad.net/charm-k8s-wordpress
diff --git a/lib/ops b/lib/ops
 new file mode 120000
index 0000000..d934193
--- /dev/null
+++ b/lib/ops
@@ -0,0 +1 @@
+../mod/operator/ops
 \ No newline at end of file
diff --git a/mod/operator b/mod/operator
 new file mode 160000
index 0000000..44dff93
--- /dev/null
+++ b/mod/operator
@@ -0,0 +1 @@
+Subproject commit 44dff930667aa8e9b179c11fa87ceb8c9b85ec5a
diff --git a/reactive/wordpress.py b/reactive/wordpress.py
 deleted file mode 100644
index 9a1b013..0000000
--- a/reactive/wordpress.py
+++ /dev/null
@@ -1,292 +0,0 @@
-import io
-import os
-import re
-import requests
-from pprint import pprint
-from urllib.parse import urlparse, urlunparse
-from yaml import safe_load
-
-from charmhelpers.core import host, hookenv
-from charms import reactive
-from charms.layer import caas_base, status
-from charms.reactive import hook, when, when_not
-
-
-@hook("upgrade-charm")
-def upgrade_charm():
-    status.maintenance("Upgrading charm")
-    reactive.clear_flag("wordpress.configured")
-
-
-@when("config.changed")
-def reconfig():
-    status.maintenance("charm configuration changed")
-    reactive.clear_flag("wordpress.configured")
-
-    # Validate config
-    valid = True
-    config = hookenv.config()
-    # Ensure required strings
-    for k in ["image", "db_host", "db_name", "db_user", "db_password"]:
-        if config[k].strip() == "":
-            status.blocked("{!r} config is required".format(k))
-            valid = False
-
-    reactive.toggle_flag("wordpress.config.valid", valid)
-
-
-@when("wordpress.config.valid")
-@when_not("wordpress.configured")
-def deploy_container():
-    spec = make_pod_spec()
-    if spec is None:
-        return  # Status already set
-    if reactive.data_changed("wordpress.spec", spec):
-        status.maintenance("configuring container")
-        try:
-            caas_base.pod_spec_set(spec)
-        except Exception as e:
-            hookenv.log("pod_spec_set failed: {}".format(e), hookenv.DEBUG)
-            status.blocked("pod_spec_set failed! Check logs and k8s dashboard.")
-            return
-    else:
-        hookenv.log("No changes to pod spec")
-    if first_install():
-        reactive.set_flag("wordpress.configured")
-
-
-@when("wordpress.configured")
-def ready():
-    status.active("Ready")
-
-
-def sanitized_container_config():
-    """Container config without secrets"""
-    config = hookenv.config()
-    if config["container_config"].strip() == "":
-        container_config = {}
-    else:
-        container_config = safe_load(config["container_config"])
-        if not isinstance(container_config, dict):
-            status.blocked("container_config is not a YAML mapping")
-            return None
-    container_config["WORDPRESS_DB_HOST"] = config["db_host"]
-    container_config["WORDPRESS_DB_NAME"] = config["db_name"]
-    container_config["WORDPRESS_DB_USER"] = config["db_user"]
-    if config.get("wp_plugin_openid_team_map"):
-        container_config["WP_PLUGIN_OPENID_TEAM_MAP"] = config["wp_plugin_openid_team_map"]
-    return container_config
-
-
-def full_container_config():
-    """Container config with secrets"""
-    config = hookenv.config()
-    container_config = sanitized_container_config()
-    if container_config is None:
-        return None
-    if config["container_secrets"].strip() == "":
-        container_secrets = {}
-    else:
-        container_secrets = safe_load(config["container_secrets"])
-        if not isinstance(container_secrets, dict):
-            status.blocked("container_secrets is not a YAML mapping")
-            return None
-    container_config.update(container_secrets)
-    # Add secrets from charm config
-    container_config["WORDPRESS_DB_PASSWORD"] = config["db_password"]
-    if config.get("wp_plugin_akismet_key"):
-        container_config["WP_PLUGIN_AKISMET_KEY"] = config["wp_plugin_akismet_key"]
-    return container_config
-
-
-def make_pod_spec():
-    config = hookenv.config()
-    container_config = sanitized_container_config()
-    if container_config is None:
-        return  # Status already set
-
-    ports = [
-        {"name": name, "containerPort": int(port), "protocol": "TCP"}
-        for name, port in [addr.split(":", 1) for addr in config["ports"].split()]
-    ]
-
-    # PodSpec v1? https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#podspec-v1-core
-    spec = {
-        "containers": [
-            {
-                "name": hookenv.charm_name(),
-                "imageDetails": {"imagePath": config["image"]},
-                "ports": ports,
-                "config": container_config,
-            }
-        ]
-    }
-    out = io.StringIO()
-    pprint(spec, out)
-    hookenv.log("Container environment config (sans secrets) <<EOM\n{}\nEOM".format(out.getvalue()))
-
-    # If we need credentials (secrets) for our image, add them to the spec after logging
-    if config.get("image_user") and config.get("image_pass"):
-        spec.get("containers")[0].get("imageDetails")["username"] = config["image_user"]
-        spec.get("containers")[0].get("imageDetails")["password"] = config["image_pass"]
-
-    config_with_secrets = full_container_config()
-    if config_with_secrets is None:
-        return None  # Status already set
-    container_config.update(config_with_secrets)
-
-    return spec
-
-
-def first_install():
-    """Perform initial configuration of wordpress if needed."""
-    config = hookenv.config()
-    if not is_pod_up("website"):
-        hookenv.log("Pod not yet ready - retrying")
-        return False
-    elif not is_vhost_ready():
-        hookenv.log("Wordpress vhost is not yet listening - retrying")
-        return False
-    elif wordpress_configured() or not config["initial_settings"]:
-        hookenv.log("No initial_setting provided or wordpress already configured. Skipping first install.")
-        return True
-    hookenv.log("Starting wordpress initial configuration")
-    payload = {
-        "admin_password": host.pwgen(24),
-        "blog_public": "checked",
-        "Submit": "submit",
-    }
-    payload.update(safe_load(config["initial_settings"]))
-    payload["admin_password2"] = payload["admin_password"]
-    if not payload["blog_public"]:
-        payload["blog_public"] = "unchecked"
-    required_config = set(("user_name", "admin_email"))
-    missing = required_config.difference(payload.keys())
-    if missing:
-        hookenv.log("Error: missing wordpress settings: {}".format(missing))
-        return False
-    call_wordpress("/wp-admin/install.php?step=2", redirects=True, payload=payload)
-    host.write_file(os.path.join("/root/", "initial.passwd"), payload["admin_password"], perms=0o400)
-    return True
-
-
-def call_wordpress(uri, redirects=True, payload={}, _depth=1):
-    max_depth = 10
-    if _depth > max_depth:
-        hookenv.log("Redirect loop detected in call_worpress()")
-        raise RuntimeError("Redirect loop detected in call_worpress()")
-    config = hookenv.config()
-    service_ip = get_service_ip("website")
-    if service_ip:
-        headers = {"Host": config["blog_hostname"]}
-        url = urlunparse(("http", service_ip, uri, "", "", ""))
-        if payload:
-            r = requests.post(url, allow_redirects=False, headers=headers, data=payload, timeout=30)
-        else:
-            r = requests.get(url, allow_redirects=False, headers=headers, timeout=30)
-        if redirects and r.is_redirect:
-            # Recurse, but strip the scheme and host first, we need to connect over HTTP by bare IP
-            o = urlparse(r.headers.get("Location"))
-            return call_wordpress(o.path, redirects=redirects, payload=payload, _depth=_depth + 1)
-        else:
-            return r
-    else:
-        hookenv.log("Error getting service IP")
-        return False
-
-
-def wordpress_configured():
-    """Check whether first install has been completed."""
-    # Check whether pod is deployed
-    if not is_pod_up("website"):
-        return False
-    # Check if we have WP code deployed at all
-    if not is_vhost_ready():
-        return False
-    # We have code on disk, check if configured
-    try:
-        r = call_wordpress("/", redirects=False)
-    except requests.exceptions.ConnectionError:
-        return False
-    if r.status_code == 302 and re.match("^.*/wp-admin/install.php", r.headers.get("location", "")):
-        return False
-    elif r.status_code == 302 and re.match("^.*/wp-admin/setup-config.php", r.headers.get("location", "")):
-        hookenv.log("MySQL database setup failed, we likely have no wp-config.php")
-        status.blocked("MySQL database setup failed, we likely have no wp-config.php")
-        return False
-    else:
-        return True
-
-
-def is_vhost_ready():
-    """Check whether wordpress is available using http."""
-    # Check if we have WP code deployed at all
-    try:
-        r = call_wordpress("/wp-login.php", redirects=False)
-    except requests.exceptions.ConnectionError:
-        hookenv.log("call_wordpress() returned requests.exceptions.ConnectionError")
-        return False
-    if r is None:
-        hookenv.log("call_wordpress() returned None")
-        return False
-    if hasattr(r, "status_code") and r.status_code in (403, 404):
-        hookenv.log("call_wordpress() returned status {}".format(r.status_code))
-        return False
-    else:
-        return True
-
-
-def get_service_ip(endpoint):
-    try:
-        info = hookenv.network_get(endpoint, hookenv.relation_id())
-        if "ingress-addresses" in info:
-            addr = info["ingress-addresses"][0]
-            if len(addr):
-                return addr
-        else:
-            hookenv.log("No ingress-addresses: {}".format(info))
-    except Exception as e:
-        hookenv.log("Caught exception checking for service IP: {}".format(e))
-
-    return None
-
-
-def is_pod_up(endpoint):
-    """Check to see if the pod of a relation is up.
-
-    application-vimdb: 19:29:10 INFO unit.vimdb/0.juju-log network info
-
-    In the example below:
-    - 10.1.1.105 is the address of the application pod.
-    - 10.152.183.199 is the service cluster ip
-
-    {
-        'bind-addresses': [{
-            'macaddress': '',
-            'interfacename': '',
-            'addresses': [{
-                'hostname': '',
-                'address': '10.1.1.105',
-                'cidr': ''
-            }]
-        }],
-        'egress-subnets': [
-            '10.152.183.199/32'
-        ],
-        'ingress-addresses': [
-            '10.152.183.199',
-            '10.1.1.105'
-        ]
-    }
-    """
-    try:
-        info = hookenv.network_get(endpoint, hookenv.relation_id())
-
-        # Check to see if the pod has been assigned its internal and external ips
-        for ingress in info["ingress-addresses"]:
-            if len(ingress) == 0:
-                return False
-    except Exception:
-        return False
-
-    return True
diff --git a/src/charm.py b/src/charm.py
 new file mode 100755
index 0000000..a19bc28
--- /dev/null
+++ b/src/charm.py
@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+
+import io
+import re
+import subprocess
+import sys
+from pprint import pprint
+from time import sleep
+from urllib.parse import urlparse, urlunparse
+from yaml import safe_load
+
+sys.path.append("lib")
+
+from ops.charm import CharmBase  # NoQA: E402
+from ops.framework import StoredState  # NoQA: E402
+from ops.main import main  # NoQA: E402
+from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus  # NoQA: E402
+
+import logging  # NoQA: E402
+
+logger = logging.getLogger()
+
+
+class Wordpress(CharmBase):
+    state = StoredState()
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        for event in (
+            self.on.start,
+            self.on.config_changed,
+        ):
+            self.framework.observe(event, self)
+
+    def on_start(self, event):
+        logger.info("Here we go...")
+        # There may be a nicer way to do this!
+        # https://github.com/canonical/operator/issues/156
+        subprocess.check_call(['apt-get', 'update'])
+        subprocess.check_call(['apt-get', '-y', 'install', 'python3-requests'])
+        # Initialise states
+        self.state._started = True
+        self.state._configured = False
+        self.state._valid = False
+
+    def on_config_changed(self, event):
+        valid = True
+        config = self.model.config
+        for k in ["image", "db_host", "db_name", "db_user", "db_password"]:
+            if config[k].strip() == "":
+                self.model.unit.status = BlockedStatus("{!r} config is required".format(k))
+                valid = False
+        self.state._valid = valid
+        self.configure_pod(event)
+
+    def sanitized_container_config(self):
+        """Container config without secrets"""
+        config = self.model.config
+        if config["container_config"].strip() == "":
+            container_config = {}
+        else:
+            container_config = safe_load(config["container_config"])
+            if not isinstance(container_config, dict):
+                self.model.unit.status = BlockedStatus("container_config is not a YAML mapping")
+                return None
+        container_config["WORDPRESS_DB_HOST"] = config["db_host"]
+        container_config["WORDPRESS_DB_NAME"] = config["db_name"]
+        container_config["WORDPRESS_DB_USER"] = config["db_user"]
+        if config.get("wp_plugin_openid_team_map"):
+            container_config["WP_PLUGIN_OPENID_TEAM_MAP"] = config["wp_plugin_openid_team_map"]
+        return container_config
+
+    def full_container_config(self):
+        """Container config with secrets"""
+        config = self.model.config
+        container_config = self.sanitized_container_config()
+        if container_config is None:
+            return None
+        if config["container_secrets"].strip() == "":
+            container_secrets = {}
+        else:
+            container_secrets = safe_load(config["container_secrets"])
+            if not isinstance(container_secrets, dict):
+                self.model.unit.status = BlockedStatus("container_secrets is not a YAML mapping")
+                return None
+        container_config.update(container_secrets)
+        # Add secrets from charm config
+        container_config["WORDPRESS_DB_PASSWORD"] = config["db_password"]
+        if config.get("wp_plugin_akismet_key"):
+            container_config["WP_PLUGIN_AKISMET_KEY"] = config["wp_plugin_akismet_key"]
+        return container_config
+
+    def make_pod_spec(self):
+        config = self.model.config
+        container_config = self.sanitized_container_config()
+        if container_config is None:
+            return  # Status already set
+
+        ports = [
+            {"name": name, "containerPort": int(port), "protocol": "TCP"}
+            for name, port in [addr.split(":", 1) for addr in config["ports"].split()]
+        ]
+
+        # PodSpec v1? https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.13/#podspec-v1-core
+        spec = {
+            "containers": [
+                {
+                    "name": self.app.name,
+                    "imageDetails": {"imagePath": config["image"]},
+                    "ports": ports,
+                    "config": container_config,
+                    "readinessProbe": {"exec": {"command": ["cat", "/srv/wordpress-helpers/.ready"]}},
+                }
+            ]
+        }
+        out = io.StringIO()
+        pprint(spec, out)
+        logger.info("Container environment config (sans secrets) <<EOM\n{}\nEOM".format(out.getvalue()))
+
+        # If we need credentials (secrets) for our image, add them to the spec after logging
+        if config.get("image_user") and config.get("image_pass"):
+            spec.get("containers")[0].get("imageDetails")["username"] = config["image_user"]
+            spec.get("containers")[0].get("imageDetails")["password"] = config["image_pass"]
+
+        config_with_secrets = self.full_container_config()
+        if config_with_secrets is None:
+            return None  # Status already set
+        container_config.update(config_with_secrets)
+
+        return spec
+
+    def first_install(self):
+        """Perform initial configuration of wordpress if needed."""
+        config = self.model.config
+        if not self.is_pod_up("website"):
+            logger.info("Pod not yet ready - retrying")
+            return False
+        elif not self.is_vhost_ready():
+            logger.info("Wordpress vhost is not yet listening - retrying")
+            return False
+        elif self.state._configured or not config["initial_settings"]:
+            logger.info("No initial_setting provided or wordpress already configured. Skipping first install.")
+            return True
+        logger.info("Starting wordpress initial configuration")
+        payload = {
+            # "admin_password": host.pwgen(24), ## TODO: pwgen
+            "admin_password": "letmein123",
+            "blog_public": "checked",
+            "Submit": "submit",
+        }
+        payload.update(safe_load(config["initial_settings"]))
+        payload["admin_password2"] = payload["admin_password"]
+        if not payload["blog_public"]:
+            payload["blog_public"] = "unchecked"
+        required_config = set(("user_name", "admin_email"))
+        missing = required_config.difference(payload.keys())
+        if missing:
+            logger.info("Error: missing wordpress settings: {}".format(missing))
+            return False
+        self.call_wordpress("/wp-admin/install.php?step=2", redirects=True, payload=payload)
+        # TODO: write_file
+        # host.write_file(os.path.join("/root/", "initial.passwd"), payload["admin_password"], perms=0o400)
+        return True
+
+    def call_wordpress(self, uri, redirects=True, payload={}, _depth=1):
+        import requests
+
+        max_depth = 10
+        if _depth > max_depth:
+            logger.info("Redirect loop detected in call_worpress()")
+            raise RuntimeError("Redirect loop detected in call_worpress()")
+        config = self.model.config
+        service_ip = self.get_service_ip("website")
+        if service_ip:
+            headers = {"Host": config["blog_hostname"]}
+            url = urlunparse(("http", service_ip, uri, "", "", ""))
+            if payload:
+                r = requests.post(url, allow_redirects=False, headers=headers, data=payload, timeout=30)
+            else:
+                r = requests.get(url, allow_redirects=False, headers=headers, timeout=30)
+            if redirects and r.is_redirect:
+                # Recurse, but strip the scheme and host first, we need to connect over HTTP by bare IP
+                o = urlparse(r.headers.get("Location"))
+                return self.call_wordpress(o.path, redirects=redirects, payload=payload, _depth=_depth + 1)
+            else:
+                return r
+        else:
+            logger.info("Error getting service IP")
+            return False
+
+    def wordpress_configured(self):
+        """Check whether first install has been completed."""
+        import requests
+
+        # Check whether pod is deployed
+        if not self.is_pod_up("website"):
+            return False
+        # Check if we have WP code deployed at all
+        if not self.is_vhost_ready():
+            return False
+        # We have code on disk, check if configured
+        try:
+            r = self.call_wordpress("/", redirects=False)
+        except requests.exceptions.ConnectionError:
+            return False
+        if r.status_code == 302 and re.match("^.*/wp-admin/install.php", r.headers.get("location", "")):
+            return False
+        elif r.status_code == 302 and re.match("^.*/wp-admin/setup-config.php", r.headers.get("location", "")):
+            logger.info("MySQL database setup failed, we likely have no wp-config.php")
+            self.model.unit.status = BlockedStatus("MySQL database setup failed, we likely have no wp-config.php")
+            return False
+        else:
+            return True
+
+    def is_vhost_ready(self):
+        """Check whether wordpress is available using http."""
+        import requests
+
+        # Check if we have WP code deployed at all
+        try:
+            r = self.call_wordpress("/wp-login.php", redirects=False)
+        except requests.exceptions.ConnectionError:
+            logger.info("call_wordpress() returned requests.exceptions.ConnectionError")
+            return False
+        if r is None:
+            logger.info("call_wordpress() returned None")
+            return False
+        if hasattr(r, "status_code") and r.status_code in (403, 404):
+            logger.info("call_wordpress() returned status {}".format(r.status_code))
+            return False
+        else:
+            return True
+
+    def get_service_ip(self, endpoint):
+        try:
+            self.model.get_binding(endpoint).network is not False
+        except Exception:
+            logger.info("We don't have networking yet")
+            return ''
+        try:
+            return str(self.model.get_binding(endpoint).network.ingress_addresses[0])
+        except Exception:
+            logger.info("We don't have any ingress addresses yet")
+            return ''
+
+    def is_pod_up(self, endpoint):
+        """Check to see if the pod of a relation is up"""
+        ingress = self.get_service_ip(endpoint)
+        if len(ingress) == 0:
+            return False
+        return True
+
+    def configure_pod(self, event):  # NoQA: C901
+        if not self.state._started:
+            return
+        if not self.state._valid:
+            return
+        elif self.model.unit.is_leader():
+            # only the leader can set_spec()
+            spec = self.make_pod_spec()
+            if spec is None:
+                return  # Status already set
+            # TODO: Figure out operator equivalent of reactive.data_changed()
+            # https://github.com/canonical/operator/issues/189
+            # if reactive.data_changed("wordpress.spec", spec):
+            # "if True" works around it, but we'll respwan on every hook run,
+            # which is decidedly sub-optimal
+            if True:
+                self.model.unit.status = MaintenanceStatus("Configuring container")
+                try:
+                    self.model.pod.set_spec(spec)
+                except Exception as e:
+                    logger.info("pod_spec_set failed: {}".format(e))
+                    self.model.unit.status = BlockedStatus("pod_spec_set failed! Check logs and k8s dashboard.")
+                    return
+            else:
+                logger.info("No changes to pod spec")
+            if not self.state._configured:
+                tries = 0
+                max_tries = 20
+                while tries < max_tries:
+                    if self.first_install():
+                        self.state._configured = True
+                        self.model.unit.status = ActiveStatus()
+                    else:
+                        tries = tries + 1
+                        logger.info("Sleeping 30s after attempt {}/{}, will try again".format(tries, max_tries))
+                        sleep(30)
+                logger.error("Giving up on configuration after attempt {}/{}".format(tries, max_tries))
+                self.model.unit.status = BlockedStatus("first_install failed! Check logs")
+
+
+if __name__ == "__main__":
+    main(Wordpress)
diff --git a/tests/unit/test_wordpress.py b/tests/unit/test_wordpress.py
index 5ade069..e69de29 100644
--- a/tests/unit/test_wordpress.py
+++ b/tests/unit/test_wordpress.py
@@ -1,64 +0,0 @@
-import os
-import shutil
-import sys
-import tempfile
-import unittest
-from unittest import mock
-
-# We also need to mock up charms.layer so we can run unit tests without having
-# to build the charm and pull in layers such as layer-status.
-sys.modules['charms.layer'] = mock.MagicMock()
-
-from charms.layer import status  # NOQA: E402
-
-# Add path to where our reactive layer lives and import.
-sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__)))))
-from reactive import wordpress  # NOQA: E402
-
-
-class TestCharm(unittest.TestCase):
-    def setUp(self):
-        self.maxDiff = None
-        self.tmpdir = tempfile.mkdtemp(prefix='charm-unittests-')
-        self.addCleanup(shutil.rmtree, self.tmpdir)
-
-        self.charm_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
-
-        patcher = mock.patch('charmhelpers.core.hookenv.log')
-        self.mock_log = patcher.start()
-        self.addCleanup(patcher.stop)
-        self.mock_log.return_value = ''
-
-        patcher = mock.patch('charmhelpers.core.hookenv.charm_dir')
-        self.mock_charm_dir = patcher.start()
-        self.addCleanup(patcher.stop)
-        self.mock_charm_dir.return_value = self.charm_dir
-
-        patcher = mock.patch('charmhelpers.core.hookenv.local_unit')
-        self.mock_local_unit = patcher.start()
-        self.addCleanup(patcher.stop)
-        self.mock_local_unit.return_value = 'mock-wordpress/0'
-
-        patcher = mock.patch('charmhelpers.core.hookenv.config')
-        self.mock_config = patcher.start()
-        self.addCleanup(patcher.stop)
-        self.mock_config.return_value = {'blog_hostname': 'myblog.example.com'}
-
-        patcher = mock.patch('charmhelpers.core.host.log')
-        self.mock_log = patcher.start()
-        self.addCleanup(patcher.stop)
-        self.mock_log.return_value = ''
-
-        status.active.reset_mock()
-        status.blocked.reset_mock()
-        status.maintenance.reset_mock()
-
-    @mock.patch('charms.reactive.clear_flag')
-    def test_hook_upgrade_charm_flags(self, clear_flag):
-        '''Test correct flags set via upgrade-charm hook'''
-        wordpress.upgrade_charm()
-        self.assertFalse(status.maintenance.assert_called())
-        want = [
-            mock.call('wordpress.configured'),
-        ]
-        self.assertFalse(clear_flag.assert_has_calls(want, any_order=True))
diff --git a/tox.ini b/tox.ini
index 7b45934..3f4c39f 100644
--- a/tox.ini
+++ b/tox.ini
@@ -10,7 +10,7 @@ setenv =
 
 [testenv:unit]
 commands =
-    pytest --ignore {toxinidir}/tests/functional \
+    pytest --ignore mod --ignore {toxinidir}/tests/functional \
       {posargs:-v  --cov=reactive --cov-report=term-missing --cov-branch}
 deps = -r{toxinidir}/tests/unit/requirements.txt
        -r{toxinidir}/requirements.txt
@@ -24,16 +24,16 @@ passenv =
   JUJU_REPOSITORY
   PATH
 commands =
-	pytest -v --ignore {toxinidir}/tests/unit {posargs}
+	pytest -v --ignore mod --ignore {toxinidir}/tests/unit {posargs}
 deps = -r{toxinidir}/tests/functional/requirements.txt
        -r{toxinidir}/requirements.txt
 
 [testenv:black]
-commands = black --skip-string-normalization --line-length=120 .
+commands = black --skip-string-normalization --line-length=120 src/ tests/
 deps = black
 
 [testenv:lint]
-commands = flake8
+commands = flake8 src/ tests/
 deps = flake8
 
 [flake8]
diff --git a/wheelhouse.txt b/wheelhouse.txt
 deleted file mode 100644
index f229360..0000000
--- a/wheelhouse.txt
+++ /dev/null
@@ -1 +0,0 @@
-requests