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

[Wouter van Bommel]

Remove several charm configuration options

Removing username, password and domain options, as it is no longer possible to register a proxy managed by this charm that way. It is replaced by the registration_bundle option.

With this change the code to register a proxy has been removed as well, and some of the unittests have been rewritten

[Jonathan Hartley (tartley)]

I don't know this repo, so won't be offended if you seek extra review, but the diffs look good to me. I have some very tiny comments in the diffs.

review: Approve

[Wouter van Bommel (woutervb)]

@Jonathan, thanks for the feedback. Added some responses and will double check the `return` question

[Otto Co-Pilot (otto-copilot)]

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

diff --git a/README.md b/README.md
index 0c0b870..9ca4d72 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ This charm will allow the installation and management of the snapstore proxy cha
 
 # 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.
+For the minimal usage a registration bundle needs to be created with the snapstore-admin tool and provided to the charm as illustrated below.
 
 ## Example bundle
 
@@ -47,13 +47,6 @@ There are some mandatory config options that have to be configured for the charm
 
       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.
diff --git a/config.yaml b/config.yaml
index 1c131a6..1a194a6 100644
--- a/config.yaml
+++ b/config.yaml
@@ -11,21 +11,4 @@ options:
       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/src/charm.py b/src/charm.py
index b75ae15..043114a 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -26,7 +26,6 @@ from resource_helpers import (
     hash_from_resource,
     install_from_resource,
     install_from_the_charmstore,
-    register_store,
     snap_details,
 )
 
@@ -73,9 +72,7 @@ class SnapstoreProxyCharm(CharmBase):
         """Handle update on the configuration of the proxy.
 
         Here we handle changes to:
-          * domain
-          * username
-          * password
+          * registration bundle
         """
         self.unit.status = MaintenanceStatus("Installing application snap")
         self.handle_installation()
@@ -93,6 +90,13 @@ class SnapstoreProxyCharm(CharmBase):
             self.evaluate_status()
             event.defer()
             return
+        else:
+            # With config options stored, we can try to configure the snap
+            for option in all_config_options:
+                if option in self.config:
+                    value = self.config[option]
+                    logger.info(f"Storing config item {option}")
+                    self._stored.__setattr__(option, value)
 
         self.handle_pgsql_dsn_change()
 
@@ -103,30 +107,14 @@ class SnapstoreProxyCharm(CharmBase):
         try:
             self.validate_config_item()
         except ConfigException as exc:
+            logger.error(f"Value for {exc.message} is invalid")
             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):
@@ -174,7 +162,7 @@ class SnapstoreProxyCharm(CharmBase):
                 self.errors.append("Failed to install the snap-store-proxy")
 
     def handle_config(self):
-
+        logger.info("Testing to see if a config value has been updated")
         # We will store dicts of item, potential new value in this list
         to_update = []
 
@@ -194,13 +182,9 @@ class SnapstoreProxyCharm(CharmBase):
             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)
 
@@ -214,25 +198,7 @@ class SnapstoreProxyCharm(CharmBase):
         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
@@ -297,39 +263,6 @@ class SnapstoreProxyCharm(CharmBase):
                     logger.debug("Stored the store id from the registration bundle")
             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)
@@ -352,25 +285,9 @@ class SnapstoreProxyCharm(CharmBase):
             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"
+                "The unit is not registered, please supply a registration_bundle"
             )
             return
 
diff --git a/src/helpers.py b/src/helpers.py
index 1a53ad2..f4000ac 100644
--- a/src/helpers.py
+++ b/src/helpers.py
@@ -46,17 +46,8 @@ def config_options():
     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":
+        if item == "registration_bundle":
             type_dict.update({item: "base64+json"})
-        else:
-            type_dict.update({item: config["options"][item]["type"]})
 
     return type_dict, default_value
 
diff --git a/src/resource_helpers.py b/src/resource_helpers.py
index 007683b..b8628bb 100644
--- a/src/resource_helpers.py
+++ b/src/resource_helpers.py
@@ -4,7 +4,7 @@
 
 import hashlib
 import logging
-from subprocess import PIPE, CalledProcessError, check_output, run
+from subprocess import PIPE, run
 
 logger = logging.getLogger(__name__)
 
@@ -39,26 +39,6 @@ def snap_details(snap):
     )
 
 
-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])
diff --git a/tests/test_charm.py b/tests/test_charm.py
index 9fdac99..b92efce 100644
--- a/tests/test_charm.py
+++ b/tests/test_charm.py
@@ -5,14 +5,14 @@
 #
 
 import base64
-import logging
+import hashlib
 import subprocess
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
 import pytest
 import yaml
-from ops.model import ActiveStatus, BlockedStatus
+from ops.model import BlockedStatus
 from ops.testing import Harness
 
 from charm import DATABASE_NAME, SnapstoreProxyCharm
@@ -49,18 +49,6 @@ class TestConfig(CharmTest):
             # 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
@@ -91,111 +79,106 @@ class TestConfig(CharmTest):
             "Snap has not been installed"
         )
 
-    def test_field_is_updated(self):
-        # Check that we have an update is the md5 matches
+    def test_on_config_changed_invalid_config_item(self):
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm.errors = []
+
+        with patch.object(self.harness.charm, "handle_pgsql_dsn_change"):
+            self.harness.update_config({"registration_bundle": "not base 64"})
+        assert (
+            "Could not parse the config option for Charm option 'registration_bundle'"
+            in self.harness.charm.errors[0]
+        )
+
+    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")
 
-        self.harness.charm._stored.domain = "My new domain"
-        self.harness.charm._stored.domain_md5 = "test"
+    def test_new_config(self):
+        self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm._stored.snap_install_source = "store"
 
+        # Simulate an update
         with patch.object(
             self.harness.charm, "do_snap_updates"
-        ) as patched_do_snap_updates:
-            self.harness.charm.handle_config()
+        ) as patched_do_snap_updates, patch.object(
+            self.harness.charm, "handle_pgsql_dsn_change"
+        ):
+            self.harness.update_config(
+                {
+                    "registration_bundle": "eyJkb21haW4iOiAic2Rmc2QiLCJwdWJs"
+                    "aWNfa2V5IjogIjEyIiwicHJpdmF0ZV9rZXkiOiAiMTIifQ=="
+                }
+            )
 
-        # This will be called with an array of dicts, containing the new
-        # md5 value and the new resource value
+        # If we update a config option with the same value it should be a noop
         patched_do_snap_updates.assert_called_once_with(
             [
                 {
-                    "name": "domain",
-                    "value": "My new domain",
-                    "md5": "79911e6e27b92c112ea0034734bf9f14",
+                    "name": "registration_bundle",
+                    "value": (
+                        "eyJkb21haW4iOiAic2Rmc2QiLCJwdWJsaWNfa2V5"
+                        "IjogIjEyIiwicHJpdmF0ZV9rZXkiOiAiMTIifQ=="
+                    ),
+                    "md5": "8ebd54932fb33367154ca70953b86288",
                 }
             ]
         )
 
-    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.
+    def test_config_has_changed(self):
         self.harness.charm._stored.db_uri = "postgresql://fake/database"
-        self.harness.charm.errors = []
+        self.harness.charm._stored.registration_bundle = "test bundle"
+        self.harness.charm._stored.registration_bundle_md5 = hashlib.md5(
+            "test bundle".encode()
+        ).hexdigest()
         self.harness.charm._stored.snap_install_source = "store"
-        self.harness.charm._stored.database_created = True
 
-        self.harness.update_config({config: value})
+        # Simulate an update
+        with patch.object(self.harness.charm, "handle_pgsql_dsn_change"):
+            self.harness.update_config(
+                {
+                    "registration_bundle": "eyJkb21haW4iOiAic2Rmc2QiLCJwdWJsaWNfa2V5"
+                    "IjogIjEyIiwicHJpdmF0ZV9rZXkiOiAiMTIifQ=="
+                }
+            )
 
-        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]
+        assert self.harness.charm._stored.registration_bundle == (
+            "eyJkb21haW4iOiAic2Rmc2QiLCJwdWJsaWNfa2V5"
+            "IjogIjEyIiwicHJpdmF0ZV9rZXkiOiAiMTIifQ=="
         )
 
-    @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):
+    def test_config_has_not_changed(self):
         self.harness.charm._stored.db_uri = "postgresql://fake/database"
+        self.harness.charm._stored.registration_bundle = (
+            "eyJkb21haW4iOiAic2Rmc2QiLCJwdWJsaWNfa2V5"
+            "IjogIjEyIiwicHJpdmF0ZV9rZXkiOiAiMTIifQ=="
+        )
+        self.harness.charm._stored.registration_bundle_md5 = (
+            "8ebd54932fb33367154ca70953b86288"
+        )
         self.harness.charm._stored.snap_install_source = "store"
 
-        with patch("charm.create_database") as patched_proxy:
-            self.harness.charm.handle_pgsql_dsn_change()
+        # Simulate an update
+        with patch.object(
+            self.harness.charm, "do_snap_updates"
+        ) as patched_do_snap_updates, patch.object(
+            self.harness.charm, "handle_pgsql_dsn_change"
+        ):
+            self.harness.update_config(
+                {
+                    "registration_bundle": "eyJkb21haW4iOiAic2Rmc2QiLCJwdWJs"
+                    "aWNfa2V5IjogIjEyIiwicHJpdmF0ZV9rZXkiOiAiMTIifQ=="
+                }
+            )
 
-        assert patched_proxy.called
-        patched_proxy.assert_called_once_with("postgresql://fake/database")
+        # If we update a config option with the same value it should be a noop
+        patched_do_snap_updates.assert_called_once_with([])
 
 
 class TestRegistrationBundle(CharmTest):
@@ -353,54 +336,29 @@ class TestStatus(CharmTest):
         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"
+            == "The unit is not registered, please supply a registration_bundle"
         )
         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._stored.domain = "dummy.domain"
+        self.harness.charm._stored.domain = "https://dummy.domain"
 
         with patch("charm.open_port"):
             self.harness.charm.evaluate_status()
 
-        assert self.harness.charm.unit.status.message == "Running on: dummy.domain"
+        assert (
+            self.harness.charm.unit.status.message == "Running on: https://dummy.domain"
+        )
 
 
 class TestEvents(CharmTest):
@@ -520,151 +478,6 @@ class TestEvents(CharmTest):
         )
 
 
-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 = "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"), patch("charm.open_port"):
-            # 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(
-            "Running on: http://localhost.localdomain"
-        )
-
-    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"), patch("charm.open_port"):
-            self.harness.update_config({"password": None})
-
-        assert self.harness.charm._stored.password == "Some value"
-        assert self.harness.charm.unit.status == ActiveStatus(
-            "Running on: http://localhost.localdomain"
-        )
-
-    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 = "http://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"), patch("charm.open_port"):
-            self.harness.update_config({"domain": "http://my.super.domain"})
-
-        assert self.harness.charm._stored.domain == "http://Some.value"
-        assert self.harness.charm.unit.status == ActiveStatus(
-            "Running on: http://Some.value"
-        )
-
-
 class TestInstallation(CharmTest):
     def test_install_from_resource(self):
         self.harness.add_resource("core", "Dummy core")
diff --git a/tests/test_resource_helpers.py b/tests/test_resource_helpers.py
index 2827148..66e7ade 100644
--- a/tests/test_resource_helpers.py
+++ b/tests/test_resource_helpers.py
@@ -1,5 +1,4 @@
-import logging
-from subprocess import PIPE, CalledProcessError
+from subprocess import PIPE
 from unittest.mock import MagicMock, call, mock_open, patch
 
 import resource_helpers
@@ -37,56 +36,6 @@ def test_snap_details():
     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: