Merge ~woutervb/snap-store-proxy-charm:start into snap-store-proxy-charm:master

[Wouter van Bommel]

Start of a basic charm

Start a charm that can be used to manage a snap-store-proxy instance
using juju.
The charm supports multiple ways to register the proxy and depends on a
postgresql relation to be present, as the database is used to store
relevant information.

The charm does not support installing a proxy in offline (detached from
the internet) mode.

Depends on https://code.launchpad.net/~woutervb/ols-goodyear/+git/ols-goodyear/+merge/415433
Depends on https://code.launchpad.net/~woutervb/ols-goodyear/+git/sdists/+merge/415434

[Przemysław Suliga (suligap)]

lgtm, +1

But noting that there're a bunch of "snapstore-proxy.*" appearing in various places. It seems like they could be changed either to snap-store-proxy or snap-store-proxy-charm depending on context -- to not introduce a yet another new name/spelling: snapstore-proxy.

review: Approve

[Wouter van Bommel (woutervb)]

> lgtm, +1
>
> But noting that there're a bunch of "snapstore-proxy.*" appearing in various
> places. It seems like they could be changed either to snap-store-proxy or
> snap-store-proxy-charm depending on context -- to not introduce a yet another
> new name/spelling: snapstore-proxy.

Thanks, have fixed this before committing

[Otto Co-Pilot (otto-copilot)]

Running landing tests failed
https://jenkins.ols.canonical.com/online-services/job/snap-store-proxy-charm/1/

diff --git a/.gitignore b/.gitignore
 new file mode 100644
index 0000000..68bf9ed
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,14 @@
+env/
+tmp/
+build/
+*.charm
+
+.coverage
+__pycache__/
+*.py[cod]
+
+.pytest_cache/
+
+juju/overlay.yaml
+
+*.snap
diff --git a/.jujuignore b/.jujuignore
 new file mode 100644
index 0000000..71c6212
--- /dev/null
+++ b/.jujuignore
@@ -0,0 +1,5 @@
+venv/
+*.py[cod]
+*.charm
+.pytest_cache/
+.git/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
 new file mode 100644
index 0000000..00133f6
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,35 @@
+# snap-store-proxy-charm
+
+## Developing
+
+The whole testing / linting and building of the charm is driven via the
+included Makefile. The most commonly used targets are:
+
+ * make test          ; creates a python virtualenv and will install the
+                        dependencies needed to run the tests
+ * make coverage      ; similar to the one above, but will also display which
+                        lines are not tested
+ * make charm         ; will build the charm from the code
+ * make deploy        ; build the charm and deploy it using juju in the current
+                        model
+ * make upgrade_charm ; build a new version of the charm, if applicable and use
+                        this to update the version deployed using the deploy  target
+ * make black         ; blackify and isort the current codebase
+ * make lint          ; check that the code is linted correctly
+ * make clean         ; remove all files that can be reproduced with make
+                        targets
+
+## Intended use case
+
+This charm is inteded to be used to deploy and manage the snapstore proxy snap.
+The snapstore proxy snap allows one to run a proxy, pointing local instances of
+snapd / ubuntu core instances to this proxy to limit outgoing connections.
+For more details, please check [the snapstore proxy snap itself](https://docs.ubuntu.com/snap-store-proxy/en/).
+
+
+## Testing
+
+The Python operator framework includes a very nice harness for testing
+operator behaviour without full deployment. Just `make test`:
+
+    make test
diff --git a/DEVELOP.md b/DEVELOP.md
 new file mode 100644
index 0000000..53f42ae
--- /dev/null
+++ b/DEVELOP.md
@@ -0,0 +1,20 @@
+# Development information
+
+This project runs its integration tests on a node that has no internet connection. To overcome this for the python libraries, an wheels repository is used, that contains the wheels that this project uses, and that can be installed.
+
+So when building on an environment that has internet connectivity it can happen that additional python dependencies are introduced, that will break the landing tests. This is not a problem, but new dependencies need to be explicitly mentioned in the commit, so that appropriate action can be taken.
+
+
+# Virtual environment
+
+By default the project creates an virtual environment under the project root, called env. This can be changed, by overriding the variable ENV when invoking make targets.
+
+
+# Most important make targets and their function
+
+- test            - Test the code
+- coverage        - Test the code and produce a coverage report, target is 100%
+- deploy          - Build the charm and deploy it with default, assumes juju is available
+- deploy-resource - Downloads some snaps and uses them as resources for a juju deployment. Only works if this machine has internet connectivity, it is not needed for the juju managed machines/containers.
+- clean           - Remove all files that don't belong in the git repository. Does NOT touch the juju model.
+ 
diff --git a/LICENSE b/LICENSE
index d645695..9d0f8e6 100644
--- a/LICENSE
+++ b/LICENSE
@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2021 Canonical
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
diff --git a/Makefile b/Makefile
 new file mode 100644
index 0000000..11342be
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,121 @@
+ENV_TMP = $(CURDIR)/env
+TMPDIR ?= $(CURDIR)/tmp
+ENV ?= $(ENV_TMP)
+CHARM_NAME = snap-store-proxy-charm
+CHARMCRAFT = $(shell which charmcraft)
+# Releases should match the run-on section in charmcraft.yaml in the same order
+RELEASES = 20.04
+CHARM_FILENAME = $(CHARM_NAME)$(subst $(noop) $(noop),,$(addsuffix -amd64, $(addprefix _ubuntu-, $(RELEASES)))).charm
+DEPS = $(shell find src -name '*.py') requirements.txt actions.yaml config.yaml metadata.yaml
+
+# Needed for Jenkins builds, but defining doesn't hurt
+OLS_WHEELS_TMP_DIR = $(TMPDIR)/dependencies
+OLS_WHEELS_DIR ?= $(OLS_WHEELS_TMP_DIR)
+OLS_WHEELS_REPO ?= lp:~ubuntuone-pqm-team/ols-goodyear/+git/wheels
+
+ifndef JENKINS_HOME
+# If not running under the landing server, don't use the wheel repository
+PIP_FLAGS :=
+VENV_FLAGS :=
+OLS_WHEELS_DIR :=
+else
+PIP_FLAGS := --find-links=$(OLS_WHEELS_DIR) --no-index
+VENV_FLAGS := --no-download --extra-search-dir=$(OLS_WHEELS_DIR)
+endif
+
+.PHONY: charm
+charm: $(CHARM_FILENAME)
+
+# Ensure that the building of the charm depends on the python files that make
+# up the charm
+$(CHARM_FILENAME): $(DEPS) $(CHARMCRAFT)
+	$(CHARMCRAFT) pack
+
+$(ENV): $(OLS_WHEELS_DIR) requirements-dev.txt requirements.txt
+	@echo Starting a new virtualenv
+	@virtualenv --clear $(VENV_FLAGS) $(ENV) 
+	@echo Installing python dependencies
+	@$(ENV)/bin/pip install $(PIP_FLAGS) -r requirements-dev.txt
+
+.PHONY: test
+test: $(ENV)
+	$(ENV)/bin/pytest
+	$(MAKE) lint
+
+.PHONY: coverage
+coverage: $(ENV)
+	$(ENV)/bin/pytest --cov=src --cov-report=
+	$(ENV)/bin/coverage report -m
+
+.PHONY: black
+black: $(ENV)
+	$(ENV)/bin/isort --profile black src tests
+	$(ENV)/bin/black src tests
+
+.PHONY: lint
+lint: $(ENV)
+	@echo Running flake8
+	@$(ENV)/bin/flake8 src tests
+	@echo Running black
+	@$(ENV)/bin/black --check src tests
+	@echo Running isort
+	@$(ENV)/bin/isort --profile black --check src tests
+
+.PHONY: clean
+clean: $(CHARMCRAFT)
+	@echo "Cleaning the project"
+	@$(CHARMCRAFT) clean
+	@# Delete the helper reference, so we don't kill shared virtualenvs
+	@rm -rf $(ENV_TMP) .pytest_cache build
+	@rm -f $(CHARM_FILENAME) .coverage
+	@rm -f *.snap
+	@rm -fr $(TMPDIR)
+	@-find . -name __pycache__ | xargs rm -rf
+
+.PHONY: deploy
+deploy: $(CHARM_FILENAME) ./juju/test-bundle.yaml ./juju/overlay.yaml
+	@echo deploying the test bundle
+	@juju deploy ./juju/test-bundle.yaml --overlay ./juju/overlay.yaml
+
+.PHONY: deploy-resource
+deploy-resource: $(CHARM_FILENAME) ./juju/test-bundle.yaml ./juju/resource-overlay.yaml ./juju/overlay.yaml core20.snap snap-store-proxy.snap
+	@echo deploying the resouce bundle
+	@juju deploy ./juju/test-bundle.yaml --overlay ./juju/resource-overlay.yaml --overlay ./juju/overlay.yaml
+
+.PHONY: upgrade_charm
+upgrade_charm: $(CHARM_FILENAME)
+	@echo Upgrading the charm with the latest version
+	@juju upgrade-charm snap-store-proxy --path ./$(CHARM_FILENAME)
+
+
+./juju/overlay.yaml:
+	@if [ -f $@ ] ; then \
+		touch $@ ; \
+	else \
+		echo "Please copy the overlay.yaml.example in the juju subdirectory" ;\
+		echo "and fill in the options to something valid" ;\
+		exit 1 ;\
+	fi
+
+$(CHARMCRAFT):
+	@if [ -f $@ ] ; then \
+		exit 0; \
+	else \
+		echo "Please install the snap snapcaft via 'sudo snap snapcraft'" ;\
+		exit 1;\
+	fi
+
+
+%.snap:
+	@echo Downloading $(@:.snap=)
+	@snap download $(@:.snap=)
+	@echo Removing the assert
+	@rm *.assert
+	@echo Renaming the snap
+	@mv $(@:.snap=)*snap $(@)
+
+$(OLS_WHEELS_DIR):
+	git clone  $(OLS_WHEELS_REPO) $(OLS_WHEELS_DIR)
+
+# The noop below is a helper variable, don't change it to something
+noop :=
diff --git a/README.md b/README.md
 new file mode 100644
index 0000000..2a76997
--- /dev/null
+++ b/README.md
@@ -0,0 +1,81 @@
+# snap-store-proxy-charm
+
+## Description
+
+This charm will allow the installation and management of the snapstore proxy charm via juju. This means that all needed settings, etc. can be done via a juju installation bundle, allowing for reproducable installations.
+
+# Usage
+
+Minimal items that have to be set are the domain this proxy runs on, and a username / password, on ubuntu one that correspond to an account that does not have 2fa enabled, and has accepted the developer agreement on snapstore.io.
+
+## Example bundle
+
+Below is a minimal bundle example that can be used to deploy the charm using juju.
+
+    applications:
+      postgresql:
+        charm: postgresql
+        channel: stable
+      snap-store-proxy:
+        charm: snap-store-proxy-charm
+        options:
+          registration_bundle: <content of registration file base64 encoded>
+
+    relations:
+    - - postgresql:db-admin
+      - snap-store-proxy:db-admin
+
+# Relations
+
+This charm depends on a postgresql database, so this charm should relate to a postgresql database, before anything else can be done.
+
+# Actions
+
+The charm supports the following actions:
+
+* **status** - Get the status result of the proxy, use like;
+
+      juju run-action snap-store-proxy/leader status --wait
+
+# Advanced options
+
+## Options
+
+There are some mandatory config options that have to be configured for the charm to work, these are:
+
+* **registration_bundle** - A bundle created with a snap called `snapstore-admin`. This tool supports accounts with 2 Factor authentication for Ubuntu One accounts, and contains everything to reproduce the proxy. This is the recommended way to configure the proxy. It is also a required way, if the machine on which the proxy is installed does not have an internet connection to the store. Easiest way to provide this option on the cli is the following:
+
+      juju config snap-store-proxy registration_bundle=$(cat <path to file created with snapstore-client> | base64)
+
+
+Or (deprecated)
+
+* **domain** - The domain on which the proxy will listen. This is needed for the registration, and the proxy itself needs to be able to resolve it. Ip addresses don't work. It has to be prepended with the protocol (http).
+* **username** - This is the username of the Ubuntu One account that will be used to register the proxy
+* **password** - The password of the above username
+
+## Juju resource usage
+
+The charm supports 2 modes to install the snapstore proxy code itself. This code is distributed as a snap from the actual snapstore, which means that the unit to which this charm is deployed, will need internet access, or at least access to the actual snapstore. If this is undesired, it is possible to deploy this charm in complete offline mode, which means that the snaps(\*) will need to be added as a resource.
+
+(\*) One will need both the `core20.snap` and the `snap-store-proxy.snap` to be added, as the snap-store-proxy.snap depends on the core.
+
+An example bundle to do such a deployment will look like the following.
+
+    applications:
+      postgresql:
+        charm: postgresql
+        channel: stable
+      snap-store-proxy:
+        charm: snap-store-proxy
+        options:
+          registration_bundle: <content of registration file base64 encoded>
+        resources:
+          snap-store-proxy: ./snap-store-proxy.snap
+          core: ./core20.snap
+
+    relations:
+    - - postgresql:db-admin
+      - snap-store-proxy:db-admin
+
+With the above example it is assumed that both the `core20.snap` and the `snap-store-proxy.snap` are available in the current directory. The snaps can be downloaded using the `snap download core20` and `snap download snap-store-proxy` resp.
diff --git a/actions.yaml b/actions.yaml
 new file mode 100644
index 0000000..feb312c
--- /dev/null
+++ b/actions.yaml
@@ -0,0 +1,9 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+# Learn more about actions at: https://juju.is/docs/sdk/actions
+status:
+  description: |
+    Get the status of the proxy services, ie 
+    juju run-action snap-store-proxy/leader status --wait
+
diff --git a/charmcraft.yaml b/charmcraft.yaml
 new file mode 100644
index 0000000..77b5206
--- /dev/null
+++ b/charmcraft.yaml
@@ -0,0 +1,16 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+# Learn more about charmcraft.yaml configuration at:
+# https://juju.is/docs/sdk/charmcraft-config
+
+type: "charm"
+bases:
+  - build-on:
+    - name: "ubuntu"
+      channel: "20.04"
+    run-on:
+    - name: "ubuntu"
+      channel: "20.04"
+
diff --git a/config.yaml b/config.yaml
 new file mode 100644
index 0000000..1c131a6
--- /dev/null
+++ b/config.yaml
@@ -0,0 +1,31 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+# We need to ensure that every entry has a value, so that a 'juju reset' is
+# always possible
+
+options:
+  registration_bundle:
+    default: null
+    desciption: |
+      A bundle created via `snapstore-proxy_registration_bundle` added as a base64 
+      encoded string. ie "$(cat <file> | base64)"
+    type: string
+  domain:
+    default: http://localhost.localdomain
+    description: Domain name for the Snap Store Proxy.
+    type: string
+  username:
+    default: null
+    description: |
+      Ubuntu one username used to register this proxy, this account cannot
+      have 2 factor authentication enabled, and needs to have accepted
+      the developer agreement on the snapstore.io website.
+    type: string
+  password:
+    default: null
+    decription: |
+      The passsword the belongs to the Ubuntu one username to register
+      this proxy.
+    type: string
+
diff --git a/conftest.py b/conftest.py
 new file mode 100644
index 0000000..31b44ee
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,10 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+import pytest
+
+
[e-mail](autouse=True)
+def dummy_install_from_the_charmstore(mocker):
+    mocker.patch("charm.install_from_the_charmstore")
diff --git a/juju/overlay.yaml.example b/juju/overlay.yaml.example
 new file mode 100644
index 0000000..d6f4220
--- /dev/null
+++ b/juju/overlay.yaml.example
@@ -0,0 +1,4 @@
+applications:
+  snap-store-proxy:
+    options:
+      registration_bundle: `cat <registation file> | base64`
diff --git a/juju/resource-overlay.yaml b/juju/resource-overlay.yaml
 new file mode 100644
index 0000000..317f11b
--- /dev/null
+++ b/juju/resource-overlay.yaml
@@ -0,0 +1,9 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+applications:
+  snap-store-proxy:
+    resources:
+      snap-store-proxy: ../snap-store-proxy.snap
+      core: ../core20.snap
diff --git a/juju/test-bundle.yaml b/juju/test-bundle.yaml
 new file mode 100644
index 0000000..0d8ed91
--- /dev/null
+++ b/juju/test-bundle.yaml
@@ -0,0 +1,20 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+applications:
+  postgresql:
+    charm: cs:postgresql
+    channel: stable
+    resources:
+      wal-e: 0
+    num_units: 1
+  snap-store-proxy:
+    charm: ../snap-store-proxy-charm_ubuntu-20.04-amd64.charm
+    num_units: 1
+
+
+relations:
+- - postgresql:db-admin
+  - snap-store-proxy:db-admin
+
diff --git a/metadata.yaml b/metadata.yaml
 new file mode 100644
index 0000000..d4997d2
--- /dev/null
+++ b/metadata.yaml
@@ -0,0 +1,33 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+
+# For a complete list of supported options, see:
+# https://discourse.charmhub.io/t/charm-metadata-v2/3674/15
+name: snap-store-proxy-charm
+description: |
+  Install and manage a snap-store-proxy on premise.
+summary: |
+  The Snap Store Proxy provides an on-premise edge proxy to the general Snap Store for your devices. Devices are registered with the proxy, and all communication with the Store will flow through the proxy.
+maintainers:
+  - Wouter van Bommel <wouter.bommel>@canonical.com
+tags:
+  - Snap store proxy
+
+subordinate: false
+
+requires:
+  db-admin:
+    interface: pgsql
+    limit: 1
+    desciprtion: Postgresql database used for charm administration, needs to connect to the db-admin interface
+
+resources:
+  snap-store-proxy:
+    type: file
+    filename: snap-store-proxy.snap
+    description: Snapstore Proxy Snap, used for offline / airgapped installation
+
+  core:
+    type: file
+    filename: core20.snap
+    description: Core snap needed for the snap-store-proxy.snap
diff --git a/ols-vms.conf b/ols-vms.conf
 new file mode 100644
index 0000000..0ff8c80
--- /dev/null
+++ b/ols-vms.conf
@@ -0,0 +1,5 @@
+vm.architecture = amd64
+vm.release = focal
+
+[snap-store-proxy-charm]
+vm.packages = build-essential, virtualenv
diff --git a/requirements-dev.txt b/requirements-dev.txt
 new file mode 100644
index 0000000..0948d86
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,14 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+-r requirements.txt
+coverage
+flake8
+black
+flake8-black
+pytest<7            # Needed due to pytest-pythonpath
+pytest-pythonpath
+pytest-mock
+pytest-xdist
+pytest-sugar
+pytest-cov
+pytest-isort
diff --git a/requirements.txt b/requirements.txt
 new file mode 100644
index 0000000..c29abf0
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,2 @@
+ops >= 1.2.0
+ops-lib-pgsql
diff --git a/setup.cfg b/setup.cfg
 new file mode 100644
index 0000000..8e3f700
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,31 @@
+[flake8]
+max-line-length = 99
+select: E,W,F,C,N
+exclude:
+  venv
+  .git
+  build
+  dist
+  *.egg_info
+extend-ignore =
+  E203
+
+[coverage:report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:
+
+ignore_errors = True
+
+[tool:pytest]
+python_paths = lib src
+addopts = --numprocesses auto --showlocals --isort
+
+[isort]
+profile = black
+
diff --git a/src/charm.py b/src/charm.py
 new file mode 100755
index 0000000..65eeb23
--- /dev/null
+++ b/src/charm.py
@@ -0,0 +1,425 @@
+#!/usr/bin/env python3
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+# Learn more at: https://juju.is/docs/sdk
+#
+
+import base64
+import hashlib
+import json
+import logging
+from urllib.parse import urlparse
+
+from ops.charm import CharmBase
+from ops.framework import StoredState
+from ops.lib import use
+from ops.main import main
+from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus, ModelError
+
+from exceptions import ConfigException
+from helpers import all_config_options, configure_proxy, default_values
+from optionvalidation import OptionValidation
+from resource_helpers import (
+    create_database,
+    get_status,
+    hash_from_resource,
+    install_from_resource,
+    install_from_the_charmstore,
+    register_store,
+    snap_details,
+)
+
+logger = logging.getLogger(__name__)
+
+
+pgsql = use("pgsql", 1, "[e-mail]")
+
+DATABASE_NAME = "snap-store-proxy"
+
+
+class SnapstoreProxyCharm(CharmBase):
+    """Charm the service."""
+
+    _stored = StoredState()
+
+    def __init__(self, *args):
+        super().__init__(*args)
+
+        self.errors = []
+
+        self.framework.observe(self.on.config_changed, self._on_config_changed)
+        self.framework.observe(self.on.update_status, self._on_update_status)
+
+        # Database stuff
+        self._stored.set_default(db_uri=None)
+        self.db = pgsql.PostgreSQLClient(
+            self, "db-admin"
+        )  # 'db-admin' relation in metadata.yaml
+        self.framework.observe(
+            self.db.on.database_relation_joined, self._on_database_relation_joined
+        )
+        self.framework.observe(
+            self.db.on.master_changed, self._on_database_master_changed
+        )
+        self.framework.observe(
+            self.db.on.database_relation_broken, self._on_database_relation_broken
+        )
+
+        # Actions
+        self.framework.observe(self.on.status_action, self._on_status_action)
+
+    def _on_config_changed(self, event):
+        """Handle update on the configuration of the proxy.
+
+        Here we handle changes to:
+          * domain
+          * username
+          * password
+        """
+        self.unit.status = MaintenanceStatus("Installing application snap")
+        self.handle_installation()
+
+        # Wait until there is a database relation ready, skip everything if not
+        if self._stored.db_uri is None:
+            logger.debug("Could not find a value for the database uri")
+            self.evaluate_status()
+            event.defer()
+            return
+
+        if getattr(self._stored, "snap_install_source", None) is None:
+            self.errors.append("Snap has not been installed")
+            logger.warning("Store is not installed")
+            self.evaluate_status()
+            event.defer()
+            return
+
+        self.handle_pgsql_dsn_change()
+
+        self.unit.status = MaintenanceStatus("Configuring application snap")
+
+        # Handle the validation and interal storage of the configuration options
+        logger.info("Parsing configuration options")
+        try:
+            self.validate_config_item()
+        except ConfigException as exc:
+            self.errors.append(f"Could not parse the config option for {exc.message}")
+            self.evaluate_status()
+            return
+        else:
+            # With config options stored, we can try to configure the snap
+            for option in all_config_options:
+
+                if getattr(self._stored, "registered", False):
+                    # We are registered, so we hold any updates of the domain
+                    if option == "domain":
+                        continue
+
+                if option in self.config:
+                    value = self.config[option]
+                    logger.debug(f"Storing {value} in {option}")
+                    self._stored.__setattr__(option, value)
+
+        # Then configure it, and only then we can attempt to configure it
+        self.handle_config()
+
+        if not getattr(self._stored, "registered", False):
+            self.unit.status = MaintenanceStatus("Registering proxy")
+            self.handle_registration(event)
+
+        self.evaluate_status()
+
+    def validate_config_item(self):
+        # We have some dependencie between the tls certificate and the domain
+        for config_name, test_type in all_config_options.items():
+            if config_name in self.config:
+                if self.config[config_name]:
+                    # Skip None values
+                    test = OptionValidation.new(test_type)
+                    test.validate(config_name, self.config[config_name])
+
+    def handle_installation(self):
+        """Install the snap-store-proxy.
+
+        We can install updates if provided via resources, but we cannot switch
+        between resource and store installation"""
+
+        # If we have the attribute snap_install_source with the value set to resource,
+        # or it is absent, we can try to install from a resource
+        if getattr(self._stored, "snap_install_source", None) in [None, "resource"]:
+            try:
+                snap = self.model.resources.fetch("snap-store-proxy")
+                core = self.model.resources.fetch("core")
+                snap_md5 = hash_from_resource(snap)
+                core_md5 = hash_from_resource(core)
+                if (getattr(self._stored, "snap_md5", None) != snap_md5) or (
+                    getattr(self._stored, "core_md5", None) != core_md5
+                ):
+                    install_from_resource(core, snap)
+                    self._stored.core_md5 = core_md5
+                    self._stored.snap_md5 = snap_md5
+                    self._stored.snap_install_source = "resource"
+                    logger.info("Installed the proxy from the resource")
+            except ModelError:
+                logger.info("Could not install snap from resource, attempting online")
+
+        if not hasattr(self._stored, "snap_install_source"):
+            try:
+                install_from_the_charmstore("snap-store-proxy")
+                self._stored.snap_install_source = "store"
+            except Exception:
+                logger.info(
+                    "Could not install online, retry again if resources are updated"
+                )
+                self.errors.append("Failed to install the snap-store-proxy")
+
+    def handle_config(self):
+
+        # We will store dicts of item, potential new value in this list
+        to_update = []
+
+        for item in all_config_options.keys():
+            logger.debug(f"Testing config item {item} for a new value")
+
+            # try to get the value from the charm config, if set
+            new_value = getattr(self._stored, item, default_values.get(item, None))
+            if new_value is None:
+                # No value set, or default for this item, skip
+                logger.debug(f"No default for {item}, skipping")
+                continue
+
+            # Now see if we have already stored it.
+            current_md5 = getattr(self._stored, f"{item}_md5", None)
+            new_md5 = hashlib.md5(new_value.encode()).hexdigest()
+            if current_md5 is None:
+                # A new entry, so we handle it
+                to_update.append({"name": item, "value": new_value, "md5": new_md5})
+                logger.info(f"Adding new item {item}")
+            elif current_md5 != new_md5:
+                # a different md5, so we update
+                to_update.append({"name": item, "value": new_value, "md5": new_md5})
+                logger.info(f"Updating value for {item}")
+            else:
+                logger.info(f"Skipping update for {item}, no new value")
+
+        self.do_snap_updates(to_update)
+
+    def do_snap_updates(self, updates):
+        """Here we handle the updates of the proxy snap.
+
+        A different method, as it will contain mappings between items and the
+        actual snap entries"""
+
+        has_registration_bundle = False
+        for item in updates:
+            has_registration_bundle |= item["name"] == "registration_bundle"
+
+        # If the has_registration_bundle is true, we omit changes to the domain
+        for item in updates:
+            if item["name"] == "domain":
+                logger.info("Configuring the domain")
+                # Handle the storage of the domain
+                # but we cannot actually store the url, so we need to break it
+                # down to the hostname only
+                hostname = urlparse(item["value"]).netloc.split(":")[0]
+                configure_proxy("proxy.domain", hostname)
+            else:
+                logger.debug(f"Nothing todo for {item['name']}")
+
+            # Ensure we record the values in the charm storage
+            setattr(self._stored, item["name"], item["value"])
+            setattr(self._stored, f"{item['name']}_md5", item["value"])
+
+        if has_registration_bundle:
+            # If this config option is set, we basically ignore the username and
+            # password and domain settings. And we take all from this field.
+            for item in updates:
+                if item["name"] == "registration_bundle":
+                    break
+            if item["value"]:
+                # A bit harsh, but this way we ensure that only this bundle is used
+                self._stored.registered = True
+            else:
+                # The value is removed / reset, so act accordingly
+                self._stored.registered = False
+                return
+
+            data = json.loads(base64.b64decode(item["value"]))
+            for entries in [
+                "domain",
+                "private_key",
+                "public_key",
+                "store_id",
+                # "store_assertion", needed once airgap mode is implemented
+            ]:
+                # see if any of these keys are missing
+                if entries not in data.keys():
+                    self.errors.append(
+                        f"Missing key {entries} in the registration bundle"
+                    )
+
+            if self.errors:
+                # Incomplete bundle(?) so stop doing anything
+                return
+
+            # Now make 2 lists, option names and values where the indexes
+            # correspond with eachother
+            options = []
+            values = []
+            for entry in data.keys():
+                if entry == "domain":
+                    options.append("proxy.domain")
+                    values.append(data[entry])
+                elif entry == "public_key":
+                    options.append("proxy.key.public")
+                    values.append(data[entry])
+                elif entry == "private_key":
+                    options.append("proxy.key.private")
+                    values.append(data[entry])
+                elif entry == "store_id":
+                    options.append("internal.store.id")
+                    values.append(data[entry])
+            configure_proxy(options, values, force=True)
+
+    def handle_registration(self, event):
+        """Try to register the store.
+
+        Depends on both a username and password provided for the registration.
+        """
+        if getattr(self._stored, "registered", False):
+            logger.info("This proxy is already registered")
+            return
+
+        if self._stored.db_uri is None:
+            logger.info("The database relation is not yet setup")
+            # defer, so we get retried in the future
+            event.defer()
+            return
+
+        if (
+            getattr(self._stored, "username", None) is None
+            or getattr(self._stored, "password", None) is None
+        ):
+            logger.info("Missing username or password, unable to register")
+            return
+
+        if getattr(self._stored, "domain", None) is None:
+            logger.info("Missing domain needed to register")
+            return
+
+        registered = register_store(self._stored.username, self._stored.password)
+        if registered:
+            logger.info("Proxy is registered successfully")
+        else:
+            logger.info("Failed to register, check logging to find the reason")
+        self._stored.registered = registered
+
+    def handle_pgsql_dsn_change(self):
+        """If the database is configured, then we try to configure the snap."""
+        installation_source = getattr(self._stored, "snap_install_source", None)
+        database_url = getattr(self._stored, "db_uri", None)
+        database_created = getattr(self._stored, "database_created", False)
+        if installation_source and database_url and not database_created:
+            logger.info("Handling the database configuration of the proxy")
+            if not hasattr(self._stored, "database_created"):
+                create_database(self._stored.db_uri)
+                self._stored.database_created = True
+
+    def evaluate_status(self):
+        """This is the only place where we can set the status to Active"""
+
+        if self.errors:
+            self.unit.status = BlockedStatus("\n".join(self.errors).strip())
+            return
+
+        if self._stored.db_uri is None:
+            self.unit.status = BlockedStatus("Missing database relation")
+            return
+
+        if not hasattr(self._stored, "username") and (
+            not getattr(self._stored, "registered", False)
+        ):
+            self.unit.status = BlockedStatus(
+                "Missing username, needed for registration"
+            )
+            return
+
+        if not hasattr(self._stored, "password") and (
+            not getattr(self._stored, "registered", False)
+        ):
+            self.unit.status = BlockedStatus(
+                "Missing password, needed for registration"
+            )
+            return
+
+        if not getattr(self._stored, "registered", False):
+            self.unit.status = BlockedStatus(
+                "The unit is not registered, please supply username and password"
+            )
+            return
+
+        self.unit.status = ActiveStatus()
+
+    def _on_update_status(self, _):
+
+        # Only the leader should update, to prevent conflicting updates
+        if not self.unit.is_leader():
+            return
+
+        version = "unknown"
+        try:
+            (name, version, snap_revision, channel, publisher, notes) = snap_details(
+                "snap-store-proxy"
+            )
+        except Exception as exc:
+            logger.info("Failure during determination of snap version", exc_info=exc)
+        logger.info(f"Setting version to {version}")
+        self.unit.set_workload_version(f"{version}")
+
+    def _on_database_relation_joined(self, event: pgsql.DatabaseRelationJoinedEvent):
+        logger.debug("Database relation joined")
+        if self.unit.is_leader():
+            logger.info("As leader informing the database of our wishes.")
+            # Provide requirements to the PostgreSQL server.
+            event.database = DATABASE_NAME  # Request database named mydbname
+            event.extensions = [
+                "btree_gist",
+            ]  # Request the btree_gist extension installed
+        elif event.database != DATABASE_NAME:
+            logger.info("Got some database event, but not for us retrying.")
+            # Leader has not yet set requirements. Defer, incase this unit
+            # becomes leader and needs to perform that operation.
+            event.defer()
+            return
+
+    def _on_database_master_changed(self, event: pgsql.MasterChangedEvent):
+        logger.debug("Called due to database master change")
+        if event.database != DATABASE_NAME:
+            # Leader has not yet set requirements. Wait until next event,
+            # or risk connecting to an incorrect database.
+            logger.info("Database is not yet setup by master, waiting for a new event.")
+            return
+
+        if event.master is not None:
+            logger.info("The database connection is ready, configuring proxy.")
+            self._stored.db_uri = event.master.uri
+            self.handle_pgsql_dsn_change()
+
+        self.evaluate_status()
+
+    def _on_database_relation_broken(self, event):
+        logger.debug("Erasing the database connection string.")
+        self._stored.db_uri = None
+
+        self.evaluate_status()
+
+    def _on_status_action(self, event):
+        output, exitcode = get_status()
+        if exitcode == 0:
+            event.set_results({"result": output})
+        else:
+            event.fail(f"Failed to get status, errorcode {exitcode}\n, result {output}")
+
+
+if __name__ == "__main__":
+    main(SnapstoreProxyCharm)
diff --git a/src/exceptions.py b/src/exceptions.py
 new file mode 100644
index 0000000..661a7c4
--- /dev/null
+++ b/src/exceptions.py
@@ -0,0 +1,23 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+
+class ConfigException(Exception):
+    def __init__(self, message):
+        self.message = message
+
+
+class UnknownTypeException(ConfigException):
+    def __init__(self, message):
+        super().__init__(
+            f"Unknown config type defined '{message}', don't know how to validate input."
+        )
+
+
+class InvalidTypeException(ConfigException):
+    def __init__(self, message, expected, value):
+        super().__init__(
+            f"Charm option '{message}' contains the wrong datatype. "
+            f"Expected type {expected}, given {value}"
+        )
diff --git a/src/helpers.py b/src/helpers.py
 new file mode 100644
index 0000000..07cf19c
--- /dev/null
+++ b/src/helpers.py
@@ -0,0 +1,60 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+import logging
+from pathlib import Path
+from subprocess import run
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+def configure_proxy(option, value, force=False):
+    """Simple wrapper around calling snap settings"""
+
+    if isinstance(option, list):
+        # Make sure that we set multiple values in one go
+        combined = []
+        for count, entry in enumerate(option):
+            combined.append(f'{entry}="{value[count]}"')
+        command = ["snap-store-proxy", "config"] + combined
+    else:
+        logger.debug(f"Running config for option {option} with value {value}")
+        command = ["snap-store-proxy", "config", f"{option}={value}"]
+
+    if force:
+        command.append("--force")
+
+    run(command)
+
+
+def config_options():
+    """Helper function to take the charm config.yaml and make it a dict.
+
+    Will return a dict with the types expected for the config items and a dict
+    with the default values (if any) for the config item.
+    Goal is to prevent duplication of this type of registration."""
+
+    config_file = Path(__file__).parent.parent / "config.yaml"
+    with open(config_file) as fh:
+        config = yaml.safe_load(fh)
+    type_dict = {}
+    default_value = {}
+    for item in config["options"].keys():
+        default = config["options"][item]["default"]
+        if default:
+            default_value.update({item: default})
+        if item == "domain":
+            type_dict.update({item: "url"})
+        elif item == "username":
+            type_dict.update({item: "email"})
+        elif item == "registration_bundle":
+            type_dict.update({item: "base64+json"})
+        else:
+            type_dict.update({item: config["options"][item]["type"]})
+
+    return type_dict, default_value
+
+
+all_config_options, default_values = config_options()
diff --git a/src/optionvalidation.py b/src/optionvalidation.py
 new file mode 100644
index 0000000..2e8efae
--- /dev/null
+++ b/src/optionvalidation.py
@@ -0,0 +1,76 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+import base64
+import json
+import re
+from logging import Logger
+
+from exceptions import InvalidTypeException, UnknownTypeException
+
+logger = Logger(__name__)
+
+
+class OptionValidation:
+    @staticmethod
+    def new(test_type):
+        if test_type == "string":
+            return OptionValidationString()
+        if test_type == "url":
+            return OptionValidationURL()
+        if test_type == "email":
+            return OptionValidationEmail()
+        if test_type == "base64+json":
+            return OptionValidationBase64Json()
+        raise UnknownTypeException(test_type)
+
+
+class OptionValidationString(OptionValidation):
+    @staticmethod
+    def validate(config_name, value):
+        logger.debug("Validating the type string for {config_name}")
+        if not isinstance(value, str):
+            raise InvalidTypeException(config_name, "string", value)
+
+
+class OptionValidationURL(OptionValidation):
+    @staticmethod
+    def validate(config_name, value):
+        logger.debug("Validating the type url for {config_name}")
+        regex = re.compile(
+            r"^(?:http)://"  # http:// or https://
+            r"(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|"
+            r"[A-Z0-9-]{2,}\.?)|"  # domain...
+            r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})"  # ...or ip
+            r"(?::\d+)?"  # optional port
+            r"(?:/?|[/?]\S+)$",
+            re.IGNORECASE,
+        )
+        if re.match(regex, value) is None:
+            raise InvalidTypeException(config_name, "url", value)
+
+
+class OptionValidationEmail(OptionValidation):
+    @staticmethod
+    def validate(config_name, value):
+        logger.debug("Validating the type email for {config_name}")
+        regex = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
+        if (not isinstance(value, str)) or (not re.fullmatch(regex, value)):
+            raise InvalidTypeException(config_name, "email", value)
+
+
+class OptionValidationBase64Json(OptionValidation):
+    @staticmethod
+    def validate(config_name, value):
+        logger.debug("Validating the type base64+json for {config_name}")
+        try:
+            result = base64.b64decode(value)
+            print(result)
+        except Exception:
+            raise InvalidTypeException(config_name, "base64", value)
+
+        try:
+            json.loads(result)
+        except Exception:
+            raise InvalidTypeException(config_name, "json", value)
diff --git a/src/resource_helpers.py b/src/resource_helpers.py
 new file mode 100644
index 0000000..007683b
--- /dev/null
+++ b/src/resource_helpers.py
@@ -0,0 +1,71 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+import hashlib
+import logging
+from subprocess import PIPE, CalledProcessError, check_output, run
+
+logger = logging.getLogger(__name__)
+
+
+def install_from_the_charmstore(snap, channel="stable"):
+    return run(["snap", "install", f"--channel={channel}", snap], check=True)
+
+
+def install_from_resource(core, proxy):
+    run(["snap", "install", "--dangerous", core], check=True)
+    run(["snap", "install", "--dangerous", proxy], check=True)
+
+
+def hash_from_resource(resource):
+    with open(resource, mode="rb") as fh:
+        hash = hashlib.md5()
+        while True:
+            buf = fh.read(4096)
+            if not buf:
+                break
+            hash.update(buf)
+    return hash.hexdigest()
+
+
+def snap_details(snap):
+    return (
+        run(["snap", "list", snap], stdout=PIPE)
+        .stdout.decode()
+        .strip()
+        .split("\n")[-1]
+        .split()
+    )
+
+
+def register_store(username, password):
+    """Use the provided username and password in an attempt to register.
+
+    Returns a boolean indicating success or failure"""
+    env = {
+        "SNAPSTORE_EMAIL": username,
+        "SNAPSTORE_PASSWORD": password,
+    }
+    try:
+        check_output(
+            ["/snap/bin/snap-store-proxy", "register", "--skip-questions"], env=env
+        )
+    except CalledProcessError as error:
+        logger.error(f"Registration of proxy failed, error; {error.output}")
+        return False
+    else:
+        logger.info("Proxy registred sucessfully")
+        return True
+
+
+def create_database(uri):
+    """Let the proxy configure the database."""
+    run(["/snap/bin/snap-store-proxy", "create-database", uri])
+
+
+def get_status():
+    """Return the status result and exitcode"""
+    result = run(["/snap/bin/snap-store-proxy", "status"], capture_output=True)
+
+    return result.stdout.decode("utf-8"), result.returncode
diff --git a/tests/__init__.py b/tests/__init__.py
 new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/__init__.py
diff --git a/tests/test_charm.py b/tests/test_charm.py
 new file mode 100644
index 0000000..6dc62f1
--- /dev/null
+++ b/tests/test_charm.py
@@ -0,0 +1,716 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+# Learn more about testing at: https://juju.is/docs/sdk/testing
+#
+
+import base64
+import logging
+import subprocess
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+import yaml
+from ops.model import ActiveStatus, BlockedStatus
+from ops.testing import Harness
+
+from charm import DATABASE_NAME, SnapstoreProxyCharm
+
+
+class CharmTest:
+    def setup_method(self):
+        self.harness = Harness(SnapstoreProxyCharm)
+        self.harness.begin()
+        cfg = yaml.safe_load(Path("config.yaml").read_text())
+        # a future, KeyError "default"; means no default value is set for the
+        # newly introduced config option
+        self.config_defaults = {
+            key: cfg["options"][key]["default"] for key in cfg["options"].keys()
+        }
+
+    def teardown_method(self):
+        self.harness.cleanup()
+
+
+class TestConfig(CharmTest):
+    def test_default_config_values(self):
+        # Our implicit requirement is that the database uri has been set.
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.database_created = True
+
+        # Since valid values will be pushed on to the proxy, we need to stub that here
+        with patch("charm.configure_proxy"):
+            # Ensure that the default values are set, as expected
+            self.harness.update_config()
+
+        for key, value in self.config_defaults.items():
+            # Accept the default value of None, for items that don't have a default value
+            assert getattr(self.harness.charm._stored, key, None) == value
+
+    def test_config_changed_option_update(self):
+        # Our implicit requirement is that the database uri has been set.
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.database_created = True
+
+        # Since valid values will be pushed on to the proxy, we need to stub that here
+        with patch("charm.configure_proxy"):
+            self.harness.update_config({"domain": "http://foo.com"})
+
+        assert self.harness.charm._stored.domain == "http://foo.com"
+
+    def test_on_config_changed(self):
+        # When there is an upodate, but no database set, we should end up with an
+        # Missing database relation blocked state
+        event = MagicMock()
+        self.harness.charm._stored.snap_install_source = "store"
+
+        self.harness.charm._on_config_changed(event)
+
+        event.defer.assert_called_once()
+        assert self.harness.charm.unit.status == BlockedStatus(
+            "Missing database relation"
+        )
+
+    def test_on_config_changed_missing_snap(self):
+        # Here we test what happens if the snap installation fails for some reason
+        event = MagicMock()
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+
+        with patch.object(
+            self.harness.charm, "handle_installation"
+        ) as patched_handle_installation:
+            self.harness.charm._on_config_changed(event)
+
+        patched_handle_installation.assert_called_once()
+        event.defer.assert_called_once()
+        assert not getattr(self.harness.charm._stored, "snap_install_source", None)
+        assert self.harness.charm.unit.status == BlockedStatus(
+            "Snap has not been installed"
+        )
+
+    def test_field_is_updated(self):
+        # Check that we have an update is the md5 matches
+
+        self.harness.charm._stored.domain = "My new domain"
+        self.harness.charm._stored.domain_md5 = "test"
+
+        with patch.object(
+            self.harness.charm, "do_snap_updates"
+        ) as patched_do_snap_updates:
+            self.harness.charm.handle_config()
+
+        # This will be called with an array of dicts, containing the new
+        # md5 value and the new resource value
+        patched_do_snap_updates.assert_called_once_with(
+            [
+                {
+                    "name": "domain",
+                    "value": "My new domain",
+                    "md5": "79911e6e27b92c112ea0034734bf9f14",
+                }
+            ]
+        )
+
+    def test_field_is_not_updated(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.domain = "My new domain"
+        # We know the md5
+        self.harness.charm._stored.domain_md5 = "79911e6e27b92c112ea0034734bf9f14"
+
+        with patch.object(
+            self.harness.charm, "do_snap_updates"
+        ) as patched_do_snap_updates:
+            self.harness.charm.handle_config()
+
+        # As there are no fields to update, we expect an empty array
+        patched_do_snap_updates.assert_called_once_with([])
+        assert len(caplog.records) == 1
+        assert caplog.records[0].message == "Skipping update for domain, no new value"
+
+    @pytest.mark.parametrize(
+        "config,value",
+        [
+            ("domain", "not.valid"),
+            ("username", 1),
+            ("password", 1),
+        ],
+    )
+    def test_config_validation_invalid(self, config, value):
+        """
+        Here we test both that tests work and fail.
+
+        Using 2 differen parameterize decorators, mean that they iterate over
+        eachother, basically multiplying the number of tests executed.
+        """
+        # Our implicit requirement is that the database uri has been set.
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm.errors = []
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.database_created = True
+
+        self.harness.update_config({config: value})
+
+        assert len(self.harness.charm.errors) == 1
+        assert (
+            f"Could not parse the config option for Charm option '{config}'"
+            in self.harness.charm.errors[0]
+        )
+
+    @pytest.mark.parametrize(
+        "config,value",
+        [
+            ("domain", "http://valid.domain"),
+            ("username", "[e-mail]"),
+            ("password", "a valid string"),
+        ],
+    )
+    def test_config_validation_valid(self, config, value):
+        """
+        Here we test both that tests work and fail.
+
+        Using 2 differen parameterize decorators, mean that they iterate over
+        eachother, basically multiplying the number of tests executed.
+        """
+        # Our implicit requirement is that the database uri has been set.
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.database_created = True
+
+        # Since valid values will be pushed on to the proxy, we need to stub that here
+        with patch("charm.configure_proxy"):
+            self.harness.update_config({config: value})
+        assert getattr(self.harness.charm._stored, config) == value
+
+    def test_handle_pgsql_dsn_change(self):
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm._stored.snap_install_source = "store"
+
+        with patch("charm.create_database") as patched_proxy:
+            self.harness.charm.handle_pgsql_dsn_change()
+
+        assert patched_proxy.called
+        patched_proxy.assert_called_once_with("postgresql://fake/database")
+
+
+class TestRegistrationBundle(CharmTest):
+    # Split off to ensure that tests are specific for what they do
+    # data that is passed to do_snap_updates has alrady been validated
+    # via the optionvalidation functions, so no need to test invalid data
+    def test_no_bundle(self):
+        assert not hasattr(self.harness.charm._stored, "registered")
+
+        self.harness.charm.do_snap_updates({})
+
+        # If we start without the registered key, and provide no bundle, no
+        # key will be added
+        assert not hasattr(self.harness.charm._stored, "registered")
+
+    def test_registration_removed(self):
+        setattr(self.harness.charm._stored, "registered", True)
+
+        self.harness.charm.do_snap_updates(
+            [{"name": "registration_bundle", "value": None}]
+        )
+
+        # We started with a key, so it will stay with us
+        assert not getattr(self.harness.charm._stored, "registered")
+
+    def test_has_incomplete_bundle_missing_all(self):
+        to_update = [
+            {
+                "name": "registration_bundle",
+                "value": base64.b64encode("{}".encode("UTF-8")),
+            }
+        ]
+
+        self.harness.charm.do_snap_updates(to_update)
+        assert len(self.harness.charm.errors) == 4
+        assert (
+            self.harness.charm.errors[0]
+            == "Missing key domain in the registration bundle"
+        )
+
+    def test_has_incomplete_bundle_added_domain(self):
+        to_update = [
+            {
+                "name": "registration_bundle",
+                "value": base64.b64encode('{"domain": "sdfsd"}'.encode("UTF-8")),
+            }
+        ]
+
+        self.harness.charm.do_snap_updates(to_update)
+        assert len(self.harness.charm.errors) == 3
+        assert (
+            self.harness.charm.errors[0]
+            == "Missing key private_key in the registration bundle"
+        )
+
+    def test_has_incomplete_bundle_added_private_key(self):
+        to_update = [
+            {
+                "name": "registration_bundle",
+                "value": base64.b64encode(
+                    '{"domain": "sdfsd",' '"private_key": "12"}'.encode("UTF-8")
+                ),
+            }
+        ]
+
+        self.harness.charm.do_snap_updates(to_update)
+        assert len(self.harness.charm.errors) == 2
+        assert (
+            self.harness.charm.errors[0]
+            == "Missing key public_key in the registration bundle"
+        )
+
+    def test_has_incomplete_bundle_added_public_key(self):
+        to_update = [
+            {
+                "name": "registration_bundle",
+                "value": base64.b64encode(
+                    '{"domain": "sdfsd",'
+                    '"public_key": "12",'
+                    '"private_key": "12"}'.encode("UTF-8")
+                ),
+            }
+        ]
+
+        self.harness.charm.do_snap_updates(to_update)
+        assert len(self.harness.charm.errors) == 1
+        assert (
+            self.harness.charm.errors[0]
+            == "Missing key store_id in the registration bundle"
+        )
+
+    # Possibly needed once airgap mode has been implemented
+    # def test_has_incomplete_bundle_added_store_id(self):
+    #     to_update = [
+    #         {
+    #             "name": "registration_bundle",
+    #             "value": base64.b64encode(
+    #                 '{"domain": "sdfsd",'
+    #                 '"public_key": "12",'
+    #                 '"store_id": "12",'
+    #                 '"private_key": "12"}'.encode("UTF-8")
+    #             ),
+    #         }
+    #     ]
+
+    #     self.harness.charm.do_snap_updates(to_update)
+    #     assert len(self.harness.charm.errors) == 1
+    #     assert (
+    #         self.harness.charm.errors[0]
+    #         == "Missing key store_assertion in the registration bundle"
+    #     )
+
+    def test_has_complete_bundle(self):
+        to_update = [
+            {
+                "name": "registration_bundle",
+                "value": base64.b64encode(
+                    '{"domain": "sdfsd",'
+                    '"public_key": "10",'
+                    '"store_id": "11",'
+                    '"store_assertion": "0",'
+                    '"private_key": "12"}'.encode("UTF-8")
+                ),
+            }
+        ]
+        with patch("charm.configure_proxy") as patched_configure:
+            self.harness.charm.do_snap_updates(to_update)
+
+        patched_configure.assert_called_once_with(
+            [
+                "proxy.domain",
+                "proxy.key.public",
+                "internal.store.id",
+                "proxy.key.private",
+            ],
+            ["sdfsd", "10", "11", "12"],
+            force=True,
+        )
+
+        assert getattr(self.harness.charm._stored, "registered", None)
+
+
+class TestStatus(CharmTest):
+    def test_status_missing_db_uri(self):
+        self.harness.charm._stored.db_uri = None
+
+        self.harness.charm.evaluate_status()
+
+        assert self.harness.charm.unit.status.message == "Missing database relation"
+        assert isinstance(self.harness.charm.unit.status, BlockedStatus)
+
+    def test_status_missing_username(self):
+        self.harness.charm._stored.db_uri = "Filled, but useless"
+
+        self.harness.charm.evaluate_status()
+
+        assert (
+            self.harness.charm.unit.status.message
+            == "Missing username, needed for registration"
+        )
+        assert isinstance(self.harness.charm.unit.status, BlockedStatus)
+
+    def test_status_missing_password(self):
+        self.harness.charm._stored.db_uri = "Filled, but useless"
+        self.harness.charm._stored.username = "minion"
+
+        self.harness.charm.evaluate_status()
+
+        assert (
+            self.harness.charm.unit.status.message
+            == "Missing password, needed for registration"
+        )
+        assert isinstance(self.harness.charm.unit.status, BlockedStatus)
+
+    def test_status_not_registered(self):
+        self.harness.charm._stored.db_uri = "Filled, but useless"
+        self.harness.charm._stored.username = "minion"
+        self.harness.charm._stored.password = "minions password"
+        self.harness.charm._stored.registered = None
+
+        self.harness.charm.evaluate_status()
+
+        assert (
+            self.harness.charm.unit.status.message
+            == "The unit is not registered, please supply username and password"
+        )
+        assert isinstance(self.harness.charm.unit.status, BlockedStatus)
+
+    def test_unit_ready(self):
+        self.harness.charm._stored.db_uri = "Filled, but useless"
+        self.harness.charm._stored.username = "minion"
+        self.harness.charm._stored.password = "minions password"
+        self.harness.charm._stored.registered = True
+
+        self.harness.charm.evaluate_status()
+
+        assert self.harness.charm.unit.status.message == ""
+
+
+class TestEvents(CharmTest):
+    def test_on_update_status(self):
+        self.harness.disable_hooks()
+        self.harness.set_leader(True)
+        self.harness.enable_hooks()
+
+        with patch("charm.snap_details") as mocked_snap_details:
+            mocked_snap_details.return_value = (None, 12, None, None, None, None)
+            self.harness.charm._on_update_status(None)
+
+        assert mocked_snap_details.called_once
+        mocked_snap_details.assert_called_once_with("snap-store-proxy")
+        assert self.harness.get_workload_version() == "12"
+
+    def test_on_update_status_exception(self):
+        self.harness.disable_hooks()
+        self.harness.set_leader(True)
+        self.harness.enable_hooks()
+
+        with patch("charm.snap_details") as mocked_snap_details:
+            mocked_snap_details.side_effect = subprocess.CalledProcessError(1, ["snap"])
+            self.harness.charm._on_update_status(None)
+
+        assert self.harness.get_workload_version() == "unknown"
+
+    def test_on_update_status_not_leader(self):
+        self.harness.disable_hooks()
+        self.harness.set_leader(False)
+        self.harness.enable_hooks()
+
+        with patch("charm.snap_details") as patched_snap_details:
+            self.harness.charm._on_update_status(None)
+
+        patched_snap_details.assert_not_called()
+
+    def test_on_database_relation_joined_as_leader(self):
+        # Disable the hooks, as the pgsql library will call get-leader via subprocess
+        self.harness.disable_hooks()
+        self.harness.set_leader(True)
+        self.harness.enable_hooks()
+        mocked_event = MagicMock()
+
+        self.harness.charm._on_database_relation_joined(mocked_event)
+
+        assert mocked_event.database == DATABASE_NAME
+        assert mocked_event.extensions == ["btree_gist"]
+
+    def test_on_database_relation_joined_as_not_leader(self):
+        # Disable the hooks, as the pgsql library will call get-leader via subprocess
+        self.harness.disable_hooks()
+        self.harness.set_leader(False)
+        self.harness.enable_hooks()
+        mocked_event = MagicMock()
+        mocked_event.database == "snap-store-proxy"
+
+        self.harness.charm._on_database_relation_joined(mocked_event)
+
+        assert mocked_event.defer.called_once
+        mocked_event.defer.assert_called_once_with()
+
+    def test_on_database_master_changed_wrong_database(self):
+        mocked_event = MagicMock()
+        mocked_event.database = "something invalid"
+
+        assert self.harness.charm._stored.db_uri is None
+
+        self.harness.charm._on_database_master_changed(mocked_event)
+
+        assert self.harness.charm._stored.db_uri is None
+
+    def test_on_database_master_changed_correct_database(self):
+        dummy_uri = "postgresql://[e-mail]"
+        mocked_event = MagicMock()
+        mocked_event.database = DATABASE_NAME
+        mocked_event.master.uri = dummy_uri
+
+        self.harness.charm._stored.snap_install_source = "store"
+
+        assert self.harness.charm._stored.db_uri is None
+
+        with patch("charm.create_database") as mocked_call:
+            self.harness.charm._on_database_master_changed(mocked_event)
+
+        assert self.harness.charm._stored.db_uri == dummy_uri
+        mocked_call.assert_called_once_with(dummy_uri)
+
+    def test_on_database_relation_broken(self):
+        self.harness.charm._stored.db_uri = "Some value"
+        with patch.object(
+            self.harness.charm, "evaluate_status"
+        ) as patched_evaluate_status:
+            self.harness.charm._on_database_relation_broken(None)
+
+        assert self.harness.charm._stored.db_uri is None
+        patched_evaluate_status.assert_called_once_with()
+
+    def test_on_status_action_succeeds(self):
+        event = MagicMock()
+        with patch("charm.get_status") as patched_get_status:
+            patched_get_status.return_value = ("String", 0)
+            self.harness.charm._on_status_action(event)
+
+        patched_get_status.assert_called_once_with()
+        event.set_results.assert_called_once_with({"result": "String"})
+
+    def test_on_status_action_fails(self):
+        event = MagicMock()
+        with patch("charm.get_status") as patched_get_status:
+            patched_get_status.return_value = ("String", 1)
+            self.harness.charm._on_status_action(event)
+
+        patched_get_status.assert_called_once_with()
+        event.fail.assert_called_once_with(
+            "Failed to get status, errorcode 1\n, result String"
+        )
+
+
+class TestRegistration(CharmTest):
+    def test_handle_registration_no_database(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+        event = MagicMock()
+
+        self.harness.charm.handle_registration(event)
+
+        assert len(caplog.records) == 1
+        assert caplog.records[0].message == "The database relation is not yet setup"
+
+    def test_handle_registration_no_details(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+
+        self.harness.charm._stored.db_uri = "postrgresql://fake/database"
+        event = MagicMock()
+
+        self.harness.charm._stored.db_uri = "postrgresql://fake/database"
+        self.harness.charm.handle_registration(event)
+
+        assert len(caplog.records) == 1
+        assert (
+            caplog.records[0].message
+            == "Missing username or password, unable to register"
+        )
+
+    def test_handle_registration_already_registered(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+
+        self.harness.charm._stored.db_uri = "postrgresql://fake/database"
+        self.harness.charm._stored.registered = True
+        event = MagicMock()
+
+        self.harness.charm.handle_registration(event)
+
+        assert len(caplog.records) == 1
+        assert caplog.records[0].message == "This proxy is already registered"
+
+    def test_handle_registration_missing_domain(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+
+        self.harness.charm._stored.db_uri = "postrgresql://fake/database"
+        self.harness.charm._stored.registered = False
+        self.harness.charm._stored.username = "[e-mail]"
+        self.harness.charm._stored.password = "password"
+        event = MagicMock()
+
+        self.harness.charm.handle_registration(event)
+
+        assert len(caplog.records) == 1
+        assert caplog.records[0].message == "Missing domain needed to register"
+
+    def test_handle_registration_register_succeeds(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+
+        self.harness.charm._stored.db_uri = "postrgresql://fake/database"
+        self.harness.charm._stored.registered = False
+        self.harness.charm._stored.username = "[e-mail]"
+        self.harness.charm._stored.password = "password"
+        self.harness.charm._stored.domain = "http://localhost"
+        event = MagicMock()
+
+        with patch("charm.register_store") as patched_registration:
+            patched_registration.return_value = True
+            self.harness.charm.handle_registration(event)
+
+        assert len(caplog.records) == 1
+        assert caplog.records[0].message == "Proxy is registered successfully"
+
+    def test_handle_registration_register_fails(self, caplog):
+        caplog.clear()
+        caplog.set_level(logging.INFO)
+
+        self.harness.charm._stored.db_uri = "postrgresql://fake/database"
+        self.harness.charm._stored.registered = False
+        self.harness.charm._stored.username = "[e-mail]"
+        self.harness.charm._stored.password = "password"
+        self.harness.charm._stored.domain = "http://localhost"
+        event = MagicMock()
+
+        with patch("charm.register_store") as patched_registration:
+            patched_registration.return_value = False
+            self.harness.charm.handle_registration(event)
+
+        assert len(caplog.records) == 1
+        assert (
+            caplog.records[0].message
+            == "Failed to register, check logging to find the reason"
+        )
+
+
+class TestSanity(CharmTest):
+    def test_empty_username_after_registration_and_active_status(self):
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.registered = True
+        self.harness.charm._stored.database_created = True
+        self.harness.charm._stored.username = "Some value"
+        self.harness.charm._stored.db_uri = "postgresql://user@host/database"
+
+        # Since valid values will be pushed on to the proxy, we need to stub that here
+        with patch("charm.configure_proxy"):
+            # This should not result in a change, as none is not possible to be passed on
+            self.harness.update_config({"username": None})
+
+        assert self.harness.charm._stored.username == "Some value"
+        assert self.harness.charm.unit.status == ActiveStatus("")
+
+    def test_empty_password_after_registration_and_active_status(self):
+        self.harness.charm._stored.registered = True
+        self.harness.charm._stored.database_created = True
+        self.harness.charm._stored.password = "Some value"
+        self.harness.charm._stored.db_uri = "postgresql://user@host/database"
+
+        # Since valid values will be pushed on to the proxy, we need to stub that here
+        with patch("charm.configure_proxy"):
+            self.harness.update_config({"password": None})
+
+        assert self.harness.charm._stored.password == "Some value"
+        assert self.harness.charm.unit.status == ActiveStatus("")
+
+    def test_update_domain_after_registration(self):
+        self.harness.charm._stored.snap_install_source = "store"
+        self.harness.charm._stored.registered = True
+        self.harness.charm._stored.database_created = True
+        self.harness.charm._stored.domain = "Some value"
+        self.harness.charm._stored.db_uri = "postgresql://user@host/database"
+
+        # Since valid values will be pushed on to the proxy, we need to stub that here
+        with patch("charm.configure_proxy"):
+            self.harness.update_config({"domain": "http://my.super.domain"})
+
+        assert self.harness.charm._stored.domain == "Some value"
+        assert self.harness.charm.unit.status == ActiveStatus("")
+
+
+class TestInstallation(CharmTest):
+    def test_install_from_resource(self):
+        self.harness.add_resource("core", "Dummy core")
+        self.harness.add_resource("snap-store-proxy", "Dummy proxy")
+
+        with patch("charm.install_from_resource") as patched_install:
+            self.harness.charm.handle_installation()
+
+        # We cannot determine the parameters, as the resources are
+        # placed in a randomly named directory
+        patched_install.assert_called_once()
+        assert self.harness.charm._stored.snap_install_source == "resource"
+        assert self.harness.charm._stored.core_md5 == "73eeccd64008a01814825637a6593bb2"
+        assert self.harness.charm._stored.snap_md5 == "97bc2632325e456ad67ca1626baa573c"
+
+    def test_upgrade_from_resource(self):
+        self.harness.charm._stored.snap_install_source = "resource"
+        self.harness.charm._stored.core_md5 = "73eeccd64008a01814825637a6593bb2"
+        self.harness.charm._stored.snap_md5 = "97bc2632325e456ad67ca1626baa573c"
+
+        self.harness.add_resource("core", "My new core")
+        self.harness.add_resource("snap-store-proxy", "My new proxy")
+
+        with patch("charm.install_from_resource") as patched_install:
+            self.harness.charm.handle_installation()
+
+        # We cannot determine the parameters, as the resources are
+        # placed in a randomly named directory
+        patched_install.assert_called_once()
+        assert self.harness.charm._stored.snap_install_source == "resource"
+        assert self.harness.charm._stored.core_md5 == "59f15fd274b73cb00369c905eeab5e70"
+        assert self.harness.charm._stored.snap_md5 == "d7486ac5da29427a54fe1d6e731bd334"
+
+    def test_install_from_store(self):
+        with patch("charm.install_from_the_charmstore") as patched_install:
+            self.harness.charm.handle_installation()
+
+        patched_install.assert_called_once_with("snap-store-proxy")
+        assert self.harness.charm._stored.snap_install_source == "store"
+        assert not hasattr(self.harness.charm._stored, "core_md5")
+        assert not hasattr(self.harness.charm._stored, "snap_md5")
+
+    def test_install_from_store_update(self):
+        # In case of an update (repeated call) nothing should happen if installed from store
+        self.harness.charm._stored.snap_install_source = "store"
+
+        with patch("charm.install_from_the_charmstore") as patched_install:
+            self.harness.charm.handle_installation()
+
+        patched_install.assert_not_called()
+        assert not hasattr(self.harness.charm._stored, "core_md5")
+        assert not hasattr(self.harness.charm._stored, "snap_md5")
+
+    def test_install_from_store_fails(self):
+        with patch("charm.install_from_the_charmstore") as patched_install:
+            patched_install.side_effect = Exception("dummy")
+            self.harness.charm.handle_installation()
+
+        patched_install.assert_called_once()
+        assert not hasattr(self.harness.charm._stored, "core_md5")
+        assert not hasattr(self.harness.charm._stored, "snap_md5")
+        assert len(self.harness.charm.errors) == 1
+        assert self.harness.charm.errors[0] == "Failed to install the snap-store-proxy"
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
 new file mode 100644
index 0000000..1e61b15
--- /dev/null
+++ b/tests/test_helpers.py
@@ -0,0 +1,56 @@
+from unittest import mock
+
+import helpers
+
+
+def test_configure_proxy():
+    with mock.patch("helpers.run") as mocked_run:
+        helpers.configure_proxy("myvalue", "myoption")
+
+    assert mocked_run.called
+    mocked_run.assert_called_once_with(
+        ["snap-store-proxy", "config", "myvalue=myoption"]
+    )
+
+
+def test_configure_proxy_list():
+    with mock.patch("helpers.run") as mocked_run:
+        options = ["one", "two"]
+        values = ["value_one", "value_two"]
+        helpers.configure_proxy(options, values)
+
+    assert mocked_run.called
+    mocked_run.assert_called_once_with(
+        ["snap-store-proxy", "config", 'one="value_one"', 'two="value_two"']
+    )
+
+
+def test_configure_proxy_forced():
+    with mock.patch("helpers.run") as mocked_run:
+        helpers.configure_proxy("myvalue", "myoption", True)
+
+    assert mocked_run.called
+    mocked_run.assert_called_once_with(
+        ["snap-store-proxy", "config", "myvalue=myoption", "--force"]
+    )
+
+
+def test_configure_proxy_list_forced():
+    with mock.patch("helpers.run") as mocked_run:
+        options = ["one", "two"]
+        values = ["value_one", "value_two"]
+        helpers.configure_proxy(options, values, True)
+
+    assert mocked_run.called
+    mocked_run.assert_called_once_with(
+        ["snap-store-proxy", "config", 'one="value_one"', 'two="value_two"', "--force"]
+    )
+
+
+def test_config_options():
+    # Not sure how to do a clean test here, as this function is made
+    # in an attempt to prevent double registration of config items
+    all_options, default_values = helpers.config_options()
+
+    for default_value_key in default_values.keys():
+        assert default_value_key in [key for key in all_options.keys()]
diff --git a/tests/test_optionvalidation.py b/tests/test_optionvalidation.py
 new file mode 100644
index 0000000..4144c79
--- /dev/null
+++ b/tests/test_optionvalidation.py
@@ -0,0 +1,136 @@
+import base64
+
+import pytest
+
+from exceptions import InvalidTypeException, UnknownTypeException
+from optionvalidation import (
+    OptionValidation,
+    OptionValidationBase64Json,
+    OptionValidationEmail,
+    OptionValidationString,
+    OptionValidationURL,
+)
+
+
+def test_string_validation_type():
+    assert isinstance(OptionValidation.new("string"), OptionValidationString)
+
+
+def test_url_validation_type():
+    assert isinstance(OptionValidation.new("url"), OptionValidationURL)
+
+
+def test_email_validation_type():
+    assert isinstance(OptionValidation.new("email"), OptionValidationEmail)
+
+
+def test_base64_json_validation_type():
+    assert isinstance(OptionValidation.new("base64+json"), OptionValidationBase64Json)
+
+
+def test_validation_raises_on_unknown():
+    with pytest.raises(UnknownTypeException):
+        OptionValidation.new("clown")
+
+
+def test_string_valid():
+    # This should neither rais an assert, or an exception
+    OptionValidation.new("string").validate("option", "string")
+
+
[e-mail](
+    "input",
+    [
+        1,
+        True,
+        [1, 2, 3],
+        (1, 2, 3),
+        {"1": 1, "2": 2},
+    ],
+)
+def test_string_invalid(input):
+    with pytest.raises(InvalidTypeException) as exc:
+        OptionValidation.new("string").validate("option", input)
+    assert str(input) in str(exc.value)
+
+
[e-mail](
+    "url",
+    [
+        "http://http.domain",
+        "http://127.0.0.1",
+        "http://localhost.localdomain",
+        "http://RanDom.cApitaLS",
+        "http://super.deep.domain.with.lots.of.dots.in.it",
+    ],
+)
+def test_url_valid(url):
+    OptionValidation.new("url").validate("option", url)
+
+
[e-mail](
+    "url",
+    [
+        "http://httpdomain",
+        "https://httpsdomain",
+        "https://https.domain",
+        "http://localhost",
+        "ftp://localhost",
+        "ftps://localhost",
+        "ssh://localhost",
+        "mailto://my.email.domain",
+    ],
+)
+def test_url_invalid(url):
+    with pytest.raises(InvalidTypeException) as exc:
+        OptionValidation.new("url").validate("option", url)
+    assert url in str(exc.value)
+
+
[e-mail](
+    "email",
+    [
+        "[e-mail]",
+        "[e-mail]",
+        "[e-mail]",
+    ],
+)
+def test_email_valid(email):
+    OptionValidation.new("email").validate("option", email)
+
+
[e-mail](
+    "email",
+    [
+        "@domain",
+        "@domain.extension",
+        "user@",
+        "user+label@",
+        "user@domain",
+    ],
+)
+def test_email_invalid(email):
+    with pytest.raises(InvalidTypeException) as exc:
+        OptionValidation.new("email").validate("option", email)
+    assert email in str(exc.value)
+
+
+def test_base64_json_valid():
+    value = base64.b64encode("{}".encode("UTF-8"))
+    OptionValidation.new("base64+json").validate("option", value)
+
+
+def test_base64_json_both_invalid():
+    value = "+_=-"
+    with pytest.raises(InvalidTypeException) as exc:
+        OptionValidation.new("base64+json").validate("option", value)
+    assert value in str(exc.value)
+    assert "base64" in str(exc.value)
+
+
+def test_base64_json_invalid():
+    value = base64.b64encode("{".encode("UTF-8"))
+    with pytest.raises(InvalidTypeException) as exc:
+        OptionValidation.new("base64+json").validate("option", value)
+    assert value.decode("UTF-8") in str(exc.value)
+    assert "json" in str(exc.value)
diff --git a/tests/test_resource_helpers.py b/tests/test_resource_helpers.py
 new file mode 100644
index 0000000..2827148
--- /dev/null
+++ b/tests/test_resource_helpers.py
@@ -0,0 +1,122 @@
+import logging
+from subprocess import PIPE, CalledProcessError
+from unittest.mock import MagicMock, call, mock_open, patch
+
+import resource_helpers
+
+
+def test_install_from_the_charmstore():
+    with patch("resource_helpers.run") as patched_run:
+        resource_helpers.install_from_the_charmstore("mysnap", "mychannel")
+
+    assert patched_run.called
+    patched_run.assert_called_once_with(
+        ["snap", "install", "--channel=mychannel", "mysnap"], check=True
+    )
+
+
+def test_install_from_resource():
+    with patch("resource_helpers.run") as patched_run:
+        resource_helpers.install_from_resource("core", "proxy")
+
+    assert patched_run.called
+    assert patched_run.call_count == 2
+    patched_run.assert_has_calls(
+        [
+            call(["snap", "install", "--dangerous", "core"], check=True),
+            call(["snap", "install", "--dangerous", "proxy"], check=True),
+        ]
+    )
+
+
+def test_snap_details():
+    with patch("resource_helpers.run") as patched_run:
+        resource_helpers.snap_details("mysnap")
+
+    assert patched_run.called
+    patched_run.assert_called_once_with(["snap", "list", "mysnap"], stdout=PIPE)
+
+
+def test_register_store_succeeds(caplog):
+    username = "[e-mail]"
+    password = "super secret"
+    env = {
+        "SNAPSTORE_EMAIL": username,
+        "SNAPSTORE_PASSWORD": password,
+    }
+    caplog.clear()
+    caplog.set_level(logging.INFO)
+
+    with patch("resource_helpers.check_output") as patched_check_output:
+        result = resource_helpers.register_store(username, password)
+
+    assert result
+    patched_check_output.assert_called_once_with(
+        ["/snap/bin/snap-store-proxy", "register", "--skip-questions"], env=env
+    )
+    assert len(caplog.records) == 1
+    assert caplog.records[0].message == "Proxy registred sucessfully"
+
+
+def test_register_store_fails(caplog):
+    username = "[e-mail]"
+    password = "super secret"
+    env = {
+        "SNAPSTORE_EMAIL": username,
+        "SNAPSTORE_PASSWORD": password,
+    }
+    caplog.clear()
+    caplog.set_level(logging.INFO)
+
+    with patch("resource_helpers.check_output") as patched_check_output:
+        patched_check_output.side_effect = CalledProcessError(
+            1,
+            ["/snap/bin/snap-store-proxy", "register", "--skip-questions"],
+            "my dummy error",
+        )
+        result = resource_helpers.register_store(username, password)
+
+    assert not result
+    patched_check_output.assert_called_once_with(
+        ["/snap/bin/snap-store-proxy", "register", "--skip-questions"], env=env
+    )
+    assert len(caplog.records) == 1
+    assert (
+        caplog.records[0].message
+        == "Registration of proxy failed, error; my dummy error"
+    )
+
+
+def test_create_database():
+    test_dsn = "postgresql://user:password@host/database"
+    with patch("resource_helpers.run") as patched_run:
+        resource_helpers.create_database(test_dsn)
+
+    assert patched_run.called
+    patched_run.assert_called_once_with(
+        ["/snap/bin/snap-store-proxy", "create-database", test_dsn]
+    )
+
+
+def test_get_status():
+    result = MagicMock()
+    result.returncode = 10
+    result.stdout = "My magic result".encode("utf-8")
+
+    with patch("resource_helpers.run") as patched_run:
+        patched_run.return_value = result
+        output, exitcode = resource_helpers.get_status()
+
+    assert patched_run.called
+    patched_run.assert_called_once_with(
+        ["/snap/bin/snap-store-proxy", "status"], capture_output=True
+    )
+    assert exitcode == 10
+    assert output == "My magic result"
+
+
+def test_hash_from_resource():
+    with patch("builtins.open", mock_open(read_data="My Dummy Resource".encode())):
+        hash = resource_helpers.hash_from_resource("dummy")
+
+    assert hash == "edfe387dbf4a72c067943c79dffa51b8"