Merge ~woutervb/various/+git/snapstore-proxy-charm:resource_installation into ~woutervb/various/+git/snapstore-proxy-charm:main

[Wouter van Bommel]

Implement the option to install from a resource

* Allow the installation from a resource, requires both a core and the
  snap-store-proxy snap to be added.
* Updated the Makefile, to include a deploy-resources target, for simple
  testing. This target will download snaps if needed.
* Ensured complete coverage of the added code.

[Przemysław Suliga (suligap)]

Added some comments and getting these lint errors:

Running flake8
./tests/test_charm.py:557:1: W293 blank line contains whitespace
./tests/test_charm.py:562:88: W292 no newline at end of file
make[1]: *** [Makefile:46: lint] Error 1

[Wouter van Bommel (woutervb)]

Thanks for the thorough review. Fixed most of the issues found.
Also ensured proper rebase etc

[Przemysław Suliga (suligap)]

Thanks, +1, but please also consider/test if snapd snap should also be required here as a resource.

The snap-store-proxy itself does bundle snapd in the offline bundle, because on fresh bionic containers it's not present if I remember correctly. Or let me know if that's wrong.

review: Approve

[Wouter van Bommel (woutervb)]

> Thanks, +1, but please also consider/test if snapd snap should also be
> required here as a resource.
>
> The snap-store-proxy itself does bundle snapd in the offline bundle, because
> on fresh bionic containers it's not present if I remember correctly. Or let me
> know if that's wrong.

You are right that it is needed on Bionic, but not on Focal. Tested by using lxd containers and juju deployments of ubuntu for both series.

For now I will drop Bionic support to overcome this problem. It can always be added if needed.

diff --git a/.gitignore b/.gitignore
index 785f70f..c30d7df 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,5 @@ __pycache__/
 .pytest_cache/
 
 juju/overlay.yaml
+
+*.snap
diff --git a/Makefile b/Makefile
index bcd2827..c79e049 100644
--- a/Makefile
+++ b/Makefile
@@ -6,7 +6,7 @@ VENV ?= $(VENV_TMP)
 CHARM_NAME = snapstore-proxy
 CHARMCRAFT = $(shell which charmcraft)
 # Releases should match the run-on section in charmcraft.yaml in the same order
-RELEASES = 20.04 18.04
+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
 
@@ -51,16 +51,22 @@ lint: $(VENV)
 .PHONY: clean
 clean: $(CHARMCRAFT)
 	@echo "Cleaning the project"
-	@# Delete the helper reference, so we don't kill shared virtualenvs
 	@$(CHARMCRAFT) clean
+	@# Delete the helper reference, so we don't kill shared virtualenvs
 	@rm -rf $(VENV_TMP) .pytest_cache build
 	@rm -f $(CHARM_FILENAME) .coverage
+	@rm -f *.snap
 
 .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
@@ -84,5 +90,14 @@ $(CHARMCRAFT):
 		exit 1;\
 	fi
 
+
+%.snap:
+	@echo Downloading $(@:.snap=)
+	@snap download $(@:.snap=)
+	@echo Removing the assert
+	@rm *.assert
+	@echo Renaming the snap
+	@mv $(@:.snap=)*snap $(@)
+
 # The noop below is a helper variable, don't change it to something
 noop :=
diff --git a/README.md b/README.md
index 7881848..cd1ef35 100644
--- a/README.md
+++ b/README.md
@@ -4,17 +4,76 @@
 
 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
+# 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
 
-## Relations
+Below is a minimal bundle example that can be used to deploy the charm using juju.
 
-This charm depends on a postgresql database, so this charm should relate to a porgresql database, before anything else can be done.
+    applications:
+      postgresql:
+        charm: cs:postgresql
+        channel: stable
+      snapstore-proxy:
+        charm: snapstore-proxy
+        options:
+          domain: http://something.not.local
+          username: [e-mail]
+          password: UserPassword
 
-## Actions
+    relations:
+    - - postgresql:db-admin
+      - snapstore-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 snapstore-proxy/leader status --wait`
+* **status** - Get the status result of the proxy, use like;
+
+  `juju run-action snapstore-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:
+
+* **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: cs:postgresql
+        channel: stable
+      snapstore-proxy:
+        charm: snapstore-proxy
+        options:
+          domain: http://something.not.local
+          username: [e-mail]
+          password: UserPassword
+        resources:
+          snap-store-proxy: ./snap-store-proxy.snap
+          core: ./core20.snap
+
+    relations:
+    - - postgresql:db-admin
+      - snapstore-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/charmcraft.yaml b/charmcraft.yaml
index b295f15..77b5206 100644
--- a/charmcraft.yaml
+++ b/charmcraft.yaml
@@ -9,9 +9,8 @@ type: "charm"
 bases:
   - build-on:
     - name: "ubuntu"
-      channel: "18.04"
+      channel: "20.04"
     run-on:
     - name: "ubuntu"
       channel: "20.04"
-    - name: "ubuntu"
-      channel: "18.04"
+
diff --git a/juju/resource-overlay.yaml b/juju/resource-overlay.yaml
new file mode 100644
index 0000000..be135a9
--- /dev/null
+++ b/juju/resource-overlay.yaml
@@ -0,0 +1,9 @@
+# Copyright 2021 Canonical
+# See LICENSE file for licensing details.
+#
+
+applications:
+  snapstore-proxy:
+    resources:
+      snap-store-proxy: ../snap-store-proxy.snap
+      core: ../core20.snap
diff --git a/juju/test-bundle.yaml b/juju/test-bundle.yaml
index e41aea5..39c1f08 100644
--- a/juju/test-bundle.yaml
+++ b/juju/test-bundle.yaml
@@ -11,7 +11,7 @@ applications:
       wal-e: 0
     num_units: 1
   snapstore-proxy:
-    charm: ../snapstore-proxy_ubuntu-20.04-amd64_ubuntu-18.04-amd64.charm
+    charm: ../snapstore-proxy_ubuntu-20.04-amd64.charm
     num_units: 1
     options:
       domain: http://something.not.local
diff --git a/metadata.yaml b/metadata.yaml
index 5d27a04..6550676 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -17,4 +17,13 @@ requires:
     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/src/charm.py b/src/charm.py
index 419643a..591965f 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -13,7 +13,7 @@ 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
+from ops.model import ActiveStatus, BlockedStatus, MaintenanceStatus, ModelError
 
 from exceptions import ConfigException
 from helpers import all_config_options, configure_proxy, default_values
@@ -21,6 +21,8 @@ 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,
@@ -41,6 +43,9 @@ class SnapstoreProxyCharm(CharmBase):
 
     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)
 
@@ -80,6 +85,15 @@ class SnapstoreProxyCharm(CharmBase):
             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
@@ -87,10 +101,9 @@ class SnapstoreProxyCharm(CharmBase):
         try:
             self.validate_config_item()
         except ConfigException as exc:
-            self.unit.status = BlockedStatus(
-                f"Could not parse the config option for {exc.message}"
-            )
-            raise
+            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:
@@ -105,7 +118,6 @@ class SnapstoreProxyCharm(CharmBase):
                     logger.debug(f"Storing {value} in {option}")
                     self._stored.__setattr__(option, value)
 
-        # Order is important, we first need to install the snap
         # Then configure it, and only then we can attempt to configure it
         self.handle_config()
 
@@ -128,9 +140,35 @@ class SnapstoreProxyCharm(CharmBase):
 
         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"):
-            install_from_the_charmstore("snap-store-proxy")
-        self._stored.snap_install_source = "store"
+            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):
 
@@ -139,12 +177,9 @@ class SnapstoreProxyCharm(CharmBase):
 
         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, None)
-            if new_value is None:
-                logger.debug(f"Value for {item} not set, trying to get default")
-                # The value is not set, see what the default is supposed to be
-                new_value = default_values.get(item, None)
+            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")
@@ -221,11 +256,23 @@ class SnapstoreProxyCharm(CharmBase):
         self._stored.registered = registered
 
     def handle_pgsql_dsn_change(self):
-        logger.info("Handling the database configuration of the proxy")
-        create_database(self._stored.db_uri)
+        """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
diff --git a/src/helpers.py b/src/helpers.py
index 6b622a7..0575279 100644
--- a/src/helpers.py
+++ b/src/helpers.py
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 def configure_proxy(option, value):
     """Simple wrapper around calling snap settings"""
     logger.debug(f"Running config for option {option} with value {value}")
-    run(["snap-proxy", "config", f"{option}={value}"])
+    run(["snap-store-proxy", "config", f"{option}={value}"])
 
 
 def config_options():
diff --git a/src/resource_helpers.py b/src/resource_helpers.py
index e5e9e76..007683b 100644
--- a/src/resource_helpers.py
+++ b/src/resource_helpers.py
@@ -2,6 +2,7 @@
 # See LICENSE file for licensing details.
 #
 
+import hashlib
 import logging
 from subprocess import PIPE, CalledProcessError, check_output, run
 
@@ -12,6 +13,22 @@ 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)
diff --git a/tests/test_charm.py b/tests/test_charm.py
index f89e6a0..a224ba7 100644
--- a/tests/test_charm.py
+++ b/tests/test_charm.py
@@ -14,7 +14,6 @@ import yaml
 from ops.model import ActiveStatus, BlockedStatus
 from ops.testing import Harness
 
-import exceptions
 from charm import DATABASE_NAME, SnapstoreProxyCharm
 
 
@@ -37,6 +36,8 @@ 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"):
@@ -44,11 +45,14 @@ class TestConfig(CharmTest):
             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"):
@@ -60,6 +64,8 @@ class TestConfig(CharmTest):
         # 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()
@@ -67,6 +73,23 @@ class TestConfig(CharmTest):
             "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
 
@@ -94,6 +117,7 @@ class TestConfig(CharmTest):
         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"
@@ -125,8 +149,17 @@ class TestConfig(CharmTest):
         """
         # Our implicit requirement is that the database uri has been set.
         self.harness.charm._stored.db_uri = "postgresql://fake/database"
-        with pytest.raises(exceptions.InvalidTypeException):
-            self.harness.update_config({config: value})
+        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",
@@ -145,6 +178,8 @@ class TestConfig(CharmTest):
         """
         # 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"):
@@ -152,11 +187,14 @@ class TestConfig(CharmTest):
         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(None)
+        patched_proxy.assert_called_once_with("postgresql://fake/database")
 
 
 class TestStatus(CharmTest):
@@ -292,6 +330,8 @@ class TestEvents(CharmTest):
         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:
@@ -428,12 +468,15 @@ class TestRegistration(CharmTest):
 
 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"
@@ -441,6 +484,7 @@ class TestSanity(CharmTest):
 
     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"
 
@@ -452,7 +496,9 @@ class TestSanity(CharmTest):
         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"
 
@@ -462,3 +508,68 @@ class TestSanity(CharmTest):
 
         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
index 3c4eaf4..730f683 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -8,7 +8,9 @@ def test_configure_proxy():
         helpers.configure_proxy("myvalue", "myoption")
 
     assert mocked_run.called
-    mocked_run.assert_called_once_with(["snap-proxy", "config", "myvalue=myoption"])
+    mocked_run.assert_called_once_with(
+        ["snap-store-proxy", "config", "myvalue=myoption"]
+    )
 
 
 def test_config_options():
diff --git a/tests/test_resource_helpers.py b/tests/test_resource_helpers.py
index 1db2005..2827148 100644
--- a/tests/test_resource_helpers.py
+++ b/tests/test_resource_helpers.py
@@ -1,6 +1,6 @@
 import logging
 from subprocess import PIPE, CalledProcessError
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock, call, mock_open, patch
 
 import resource_helpers
 
@@ -15,6 +15,20 @@ def test_install_from_the_charmstore():
     )
 
 
+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")
@@ -99,3 +113,10 @@ def test_get_status():
     )
     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"