Merge ~mthaddon/charm-k8s-gunicorn/+git/charm-k8s-gunicorn:pebble into charm-k8s-gunicorn:master

[Tom Haddon]

Test of pebble version of the charm

Test of pebble version of the charm.

$ git clone -b 2.9 https://github.com/juju/juju
$ cd juju
$ make install
$ make microk8s-operator-update # to make the microk8s image and push to Docker
$ export PATH="/home/${USER}/go/bin:$PATH"
$ juju bootstrap microk8s
$ juju add-model gunicorn
$ juju deploy ./gunicorn.charm --resource gunicorn-image='gunicorncharmers/gunicorn-app:20.0.4-20.04_edge'

Once deployed, check juju status for the IP address and then visit that in a browser. You should see something like:

------------------
One of the nice things about the new operator framework is how easy it is to get started.
KUBERNETES_SERVICE_PORT_HTTPS: 443
KUBERNETES_SERVICE_PORT: 443
GUNICORN_PORT: tcp://10.152.183.237:65535
HOSTNAME: gunicorn-0
JUJU_CONTAINER_NAME: gunicorn
MODELOPERATOR_PORT_17071_TCP_ADDR: 10.152.183.72
GUNICORN_SERVICE_HOST: 10.152.183.237
PEBBLE_SOCKET: /charm/container/pebble.socket
PWD: /srv/gunicorn
HOME: /root
KUBERNETES_PORT_443_TCP: tcp://10.152.183.1:443
GUNICORN_PORT_65535_TCP_PROTO: tcp
MODELOPERATOR_SERVICE_HOST: 10.152.183.72
GUNICORN_PORT_65535_TCP_ADDR: 10.152.183.237
GUNICORN_SERVICE_PORT_PLACEHOLDER: 65535
GUNICORN_PORT_65535_TCP_PORT: 65535
APP_WSGI: app:app
APP_NAME: my-awesome-app
SHLVL: 0
MODELOPERATOR_PORT_17071_TCP: tcp://10.152.183.72:17071
KUBERNETES_PORT_443_TCP_PROTO: tcp
KUBERNETES_PORT_443_TCP_ADDR: 10.152.183.1
MODELOPERATOR_PORT_17071_TCP_PORT: 17071
GUNICORN_PORT_65535_TCP: tcp://10.152.183.237:65535
MODELOPERATOR_PORT: tcp://10.152.183.72:17071
KUBERNETES_SERVICE_HOST: 10.152.183.1
KUBERNETES_PORT: tcp://10.152.183.1:443
KUBERNETES_PORT_443_TCP_PORT: 443
PATH: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
GUNICORN_SERVICE_PORT: 65535
MODELOPERATOR_PORT_17071_TCP_PROTO: tcp
DEBIAN_FRONTEND: noninteractive
MODELOPERATOR_SERVICE_PORT: 17071
LC_CTYPE: C.UTF-8
SERVER_SOFTWARE: gunicorn/20.0.4
------------------

To test juju config updates, create a yaml file with the following sample contents:

FOOD: burgers
DRINK: ale

Then run `juju config gunicorn environment=@${PATH_TO_FILENAME}`.

This charm handles an upgrade-charm hook (assuming it's not failing due to config issues as above.

Next steps:
- Handle relations.
- Update unit tests.
- Document missing functionality versus the current implementation.

786a573... by Tom Haddon on 2021-03-11

Comment out series in metadata.yaml and add empty manifest.yaml

eba7f4a... by Tom Haddon on 2021-03-11

Manifest yaml needs an empty dict, try to include env vars in pebble config by defining and then dumping to yaml

52d1486... by Tom Haddon on 2021-03-11

Apply black formatting

373c49c... by Tom Haddon on 2021-03-12

Fix up the pebble config structure based on feedback from jnsgruk

096a11a... by Tom Haddon on 2021-03-12

No need to run _make_pod_env twice

6b856a5... by Tom Haddon on 2021-03-12

Update to use specific version of the operator framework that snappass-test uses

e53d086... by Tom Haddon on 2021-03-12

Remove image configuration since we're switching to oci resources

6abe151... by Tom Haddon on 2021-03-12

Remove unused textwrap

c5ec8a4... by Tom Haddon on 2021-03-12

Set a default external hostname for easier devel deploys

635d741... by Tom Haddon on 2021-03-12

Get OCI image details so we can get past pod-spec-set

2b5702f... by Tom Haddon on 2021-03-12

Comment out legacy hooks for now, only pass pod_env_config if we have some to pass

966c4b3... by Tom Haddon on 2021-03-15

Begin trying to handle config changed hook

7402e87... by Tom Haddon on 2021-03-15

Refactor how we generate pebble config

e20825e... by Tom Haddon on 2021-03-15

Remove unused copy module

610fe9e... by Tom Haddon on 2021-03-15

Make the return values of the get_pebble_config function of a consistent type, improve logging of pebble_config

fc03593... by Tom Haddon on 2021-03-15

Remove unused code, migrate checks for template variables into the right place

01b829b... by Tom Haddon on 2021-03-16

Remove obsolete tests, handle upgrade-charm hook

24dbd63... by Tom Haddon on 2021-03-16

Remove commented hook handlers - no longer needed as a reference

b4f9f6a... by Tom Haddon on 2021-03-16

Switch to archive zip so we always get the latest version of the framework

688b00e... by Tom Haddon on 2021-03-21

Pin to specific version of the operator framework to avoid needing to rebuild juju with version that supports pebble_ready vs. workload_ready

6d3bdd5... by Tom Haddon on 2021-03-25

Update for new pebble events and metadata.yaml changes

fa0fe9e... by Tom Haddon on 2021-03-26

Metadata updates for rc8

e993422... by Tom Haddon on 2021-03-26

Implement the ingress relation

295358c... by Tom Haddon on 2021-03-29

Use application rather than unit data for ingress relation

6d1a2da... by Tom Haddon on 2021-03-30

Pass a dict directly to pebble now it supports that, add a comment about is_running helper method

5969f8f... by Tom Haddon on 2021-03-31

Use the application name rather than the model name to create the ingress service

f8c5a96... by Tom Haddon on 2021-03-31

Include return value hint for ingress relation changed handler

203f1a7... by Tom Haddon on 2021-04-02

Use the new ingress library

2cef81d... by Tom Haddon on 2021-04-02

Increment patch number

59862e5... by Tom Haddon on 2021-04-06

Update ingress relation, and handle config changes

ff3ed82... by Tom Haddon on 2021-04-08

Use new approach to ingress

0e93a5d... by Tom Haddon on 2021-04-08

Use ServiceStatus to determine whether to stop and start the service

309793e... by Tom Haddon on 2021-04-12

Switch to nginx-ingress-integrator library

c3f137e... by Tom Haddon on 2021-04-15

Remove manifest.yaml which is now machine-generated

9cf5653... by Tom Haddon on 2021-04-23

Remove bases from metadata.yaml, no longer needed

Unmerged commits

9cf5653... by Tom Haddon on 2021-04-23

Remove bases from metadata.yaml, no longer needed

c3f137e... by Tom Haddon on 2021-04-15

Remove manifest.yaml which is now machine-generated

309793e... by Tom Haddon on 2021-04-12

Switch to nginx-ingress-integrator library

0e93a5d... by Tom Haddon on 2021-04-08

Use ServiceStatus to determine whether to stop and start the service

ff3ed82... by Tom Haddon on 2021-04-08

Use new approach to ingress

59862e5... by Tom Haddon on 2021-04-06

Update ingress relation, and handle config changes

2cef81d... by Tom Haddon on 2021-04-02

Increment patch number

203f1a7... by Tom Haddon on 2021-04-02

Use the new ingress library

f8c5a96... by Tom Haddon on 2021-03-31

Include return value hint for ingress relation changed handler

5969f8f... by Tom Haddon on 2021-03-31

Use the application name rather than the model name to create the ingress service

diff --git a/lib/charms/nginx_ingress_integrator/v0/ingress.py b/lib/charms/nginx_ingress_integrator/v0/ingress.py
new file mode 100644
index 0000000..65d08a7
--- /dev/null
+++ b/lib/charms/nginx_ingress_integrator/v0/ingress.py
@@ -0,0 +1,174 @@
+"""Library for the ingress relation.
+
+This library contains the Requires and Provides classes for handling
+the ingress interface.
+
+Import `IngressRequires` in your charm, with two required options:
+    - "self" (the charm itself)
+    - config_dict
+
+`config_dict` accepts the following keys:
+    - service-hostname (required)
+    - service-name (required)
+    - service-port (required)
+    - limit-rps
+    - limit-whitelist
+    - max_body-size
+    - retry-errors
+    - service-namespace
+    - session-cookie-max-age
+    - tls-secret-name
+
+See `config.yaml` for descriptions of each, along with the required type.
+
+As an example:
+```
+from charms.nginx_ingress_integrator.v0.ingress import IngressRequires
+
+# In your charm's `__init__` method.
+self.ingress = IngressRequires(self, {"service-hostname": self.config["external_hostname"],
+                                      "service-name": self.app.name,
+                                      "service-port": 80})
+
+# In your charm's `config-changed` handler.
+self.ingress.update_config({"service-hostname": self.config["external_hostname"]})
+```
+"""
+
+import logging
+
+from ops.charm import CharmEvents
+from ops.framework import EventBase, EventSource, Object
+from ops.model import BlockedStatus
+
+# The unique Charmhub library identifier, never change it
+LIBID = "db0af4367506491c91663468fb5caa4c"
+
+# Increment this major API version when introducing breaking changes
+LIBAPI = 0
+
+# Increment this PATCH version before using `charmcraft push-lib` or reset
+# to 0 if you are raising the major API version
+LIBPATCH = 1
+
+logger = logging.getLogger(__name__)
+
+REQUIRED_INGRESS_RELATION_FIELDS = {
+    "service-hostname",
+    "service-name",
+    "service-port",
+}
+
+OPTIONAL_INGRESS_RELATION_FIELDS = {
+    "limit-rps",
+    "limit-whitelist",
+    "max-body-size",
+    "retry-errors",
+    "service-namespace",
+    "session-cookie-max-age",
+    "tls-secret-name",
+}
+
+
+class IngressAvailableEvent(EventBase):
+    pass
+
+
+class IngressCharmEvents(CharmEvents):
+    """Custom charm events."""
+
+    ingress_available = EventSource(IngressAvailableEvent)
+
+
+class IngressRequires(Object):
+    """This class defines the functionality for the 'requires' side of the 'ingress' relation.
+
+    Hook events observed:
+        - relation-changed
+    """
+
+    def __init__(self, charm, config_dict):
+        super().__init__(charm, "ingress")
+
+        self.framework.observe(charm.on["ingress"].relation_changed, self._on_relation_changed)
+
+        self.config_dict = config_dict
+
+    def _config_dict_errors(self, update_only=False):
+        """Check our config dict for errors."""
+        block_status = False
+        unknown = [
+            x for x in self.config_dict if x not in REQUIRED_INGRESS_RELATION_FIELDS | OPTIONAL_INGRESS_RELATION_FIELDS
+        ]
+        if unknown:
+            logger.error("Unknown key(s) in config dictionary found: %s", ", ".join(unknown))
+            block_status = True
+        if not update_only:
+            missing = [x for x in REQUIRED_INGRESS_RELATION_FIELDS if x not in self.config_dict]
+            if missing:
+                logger.error("Missing required key(s) in config dictionary: %s", ", ".join(missing))
+                block_status = True
+        if block_status:
+            self.model.unit.status = BlockedStatus("Error in ingress relation, check `juju debug-log`")
+            return True
+        return False
+
+    def _on_relation_changed(self, event):
+        """Handle the relation-changed event."""
+        # `self.unit` isn't available here, so use `self.model.unit`.
+        if self.model.unit.is_leader():
+            if self._config_dict_errors():
+                return
+            for key in self.config_dict:
+                event.relation.data[self.model.app][key] = str(self.config_dict[key])
+
+    def update_config(self, config_dict):
+        """Allow for updates to relation."""
+        if self.model.unit.is_leader():
+            self.config_dict = config_dict
+            if self._config_dict_errors(update_only=True):
+                return
+            relation = self.model.get_relation("ingress")
+            if relation:
+                for key in self.config_dict:
+                    relation.data[self.model.app][key] = str(self.config_dict[key])
+
+
+class IngressProvides(Object):
+    """This class defines the functionality for the 'provides' side of the 'ingress' relation.
+
+    Hook events observed:
+        - relation-changed
+    """
+
+    def __init__(self, charm):
+        super().__init__(charm, "ingress")
+        # Observe the relation-changed hook event and bind
+        # self.on_relation_changed() to handle the event.
+        self.framework.observe(charm.on["ingress"].relation_changed, self._on_relation_changed)
+        self.charm = charm
+
+    def _on_relation_changed(self, event):
+        """Handle a change to the ingress relation.
+
+        Confirm we have the fields we expect to receive."""
+        # `self.unit` isn't available here, so use `self.model.unit`.
+        if not self.model.unit.is_leader():
+            return
+
+        ingress_data = {
+            field: event.relation.data[event.app].get(field)
+            for field in REQUIRED_INGRESS_RELATION_FIELDS | OPTIONAL_INGRESS_RELATION_FIELDS
+        }
+
+        missing_fields = sorted(
+            [field for field in REQUIRED_INGRESS_RELATION_FIELDS if ingress_data.get(field) is None]
+        )
+
+        if missing_fields:
+            logger.error("Missing required data fields for ingress relation: {}".format(", ".join(missing_fields)))
+            self.model.unit.status = BlockedStatus("Missing fields for ingress: {}".format(", ".join(missing_fields)))
+
+        # Create an event that our charm can use to decide it's okay to
+        # configure the ingress.
+        self.charm.on.ingress_available.emit()
diff --git a/metadata.yaml b/metadata.yaml
index b1a1aa7..37ac9d9 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -5,6 +5,7 @@ description: |
   Gunicorn charm
 summary: |
   Gunicorn charm
+<<<<<<< metadata.yaml
 series: [kubernetes]
 min-juju-version: 2.8.0  # charm storage in state
 resources:
@@ -13,6 +14,18 @@ resources:
     description: docker image for Gunicorn
     auto-fetch: true
     upstream-source: 'gunicorncharmers/gunicorn-app:20.0.4-20.04_edge'
+=======
+
+containers:
+  gunicorn:
+    resource: gunicorn-image
+
+resources:
+  gunicorn-image:
+    type: oci-image
+    description: Docker image for gunicorn to run
+
+>>>>>>> metadata.yaml
 requires:
   pg:
     interface: pgsql
@@ -20,3 +33,5 @@ requires:
   influxdb:
     interface: influxdb-api
     limit: 1
+  ingress:
+    interface: ingress
diff --git a/requirements.txt b/requirements.txt
index 6b14e66..9313aff 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,3 @@
-ops
+https://github.com/canonical/operator/archive/refs/heads/master.zip
 ops-lib-pgsql
 https://github.com/juju-solutions/resource-oci-image/archive/master.zip
diff --git a/src/charm.py b/src/charm.py
index c25df78..13524f7 100755
--- a/src/charm.py
+++ b/src/charm.py
@@ -6,6 +6,7 @@ from jinja2 import Environment, BaseLoader, meta
 import logging
 import yaml
 
+from charms.nginx_ingress_integrator.v0.ingress import IngressRequires
 import ops
 from oci_image import OCIImageResource, OCIImageResourceError
 from ops.framework import StoredState
@@ -14,8 +15,8 @@ from ops.main import main
 from ops.model import (
     ActiveStatus,
     BlockedStatus,
-    MaintenanceStatus,
 )
+from ops.pebble import ServiceStatus
 import pgsql
 
 
@@ -28,13 +29,13 @@ JUJU_CONFIG_YAML_DICT_ITEMS = ['environment']
 class GunicornK8sCharmJujuConfigError(Exception):
     """Exception when the Juju config is bad."""
 
-    pass
-
 
 class GunicornK8sCharmYAMLError(Exception):
     """Exception raised when parsing YAML fails"""
 
-    pass
+
+class GunicornK8sWaitingForRelationsError(Exception):
+    """Exception when waiting for relations."""
 
 
 class GunicornK8sCharm(CharmBase):
@@ -43,18 +44,134 @@ class GunicornK8sCharm(CharmBase):
     def __init__(self, *args):
         super().__init__(*args)
 
+<<<<<<< src/charm.py
         self.image = OCIImageResource(self, 'gunicorn-image')
 
         self.framework.observe(self.on.start, self._configure_pod)
         self.framework.observe(self.on.config_changed, self._configure_pod)
         self.framework.observe(self.on.leader_elected, self._configure_pod)
         self.framework.observe(self.on.upgrade_charm, self._configure_pod)
+=======
+        self.framework.observe(self.on.config_changed, self._on_config_changed)
+        self.framework.observe(self.on.upgrade_charm, self._on_upgrade_charm)
+        self.framework.observe(self.on.gunicorn_pebble_ready, self._on_gunicorn_pebble_ready)
+
+        self.ingress = IngressRequires(
+            self,
+            {
+                "service-hostname": self.config["external_hostname"],
+                "service-name": self.app.name,
+                "service-port": 80,
+            },
+        )
+>>>>>>> src/charm.py
 
-        # For special-cased relations
-        self._stored.set_default(reldata={})
+        self._stored.set_default(
+            gunicorn_pebble_ready=False,
+            reldata={},
+        )
 
         self._init_postgresql_relation()
 
+    def _get_pebble_config(self, event: ops.framework.EventBase) -> dict:
+        """Generate pebble config."""
+        pebble_config = {
+            "summary": "gunicorn layer",
+            "description": "gunicorn layer",
+            "services": {
+                "gunicorn": {
+                    "override": "replace",
+                    "summary": "gunicorn service",
+                    "command": "/srv/gunicorn/run",
+                    "startup": "enabled",
+                }
+            },
+        }
+
+        # Update pod environment config.
+        try:
+            pod_env_config = self._make_pod_env()
+        except GunicornK8sCharmJujuConfigError as e:
+            logger.exception("Error getting pod_env_config: %s", e)
+            self.unit.status = BlockedStatus('Error getting pod_env_config')
+            return {}
+        except GunicornK8sWaitingForRelationsError as e:
+            self.unit.status = BlockedStatus(str(e))
+            event.defer()
+            return {}
+
+        try:
+            self._check_juju_config()
+        except GunicornK8sCharmJujuConfigError as e:
+            self.unit.status = BlockedStatus(str(e))
+            return {}
+
+        if pod_env_config:
+            pebble_config["services"]["gunicorn"]["environment"] = pod_env_config
+        return pebble_config
+
+    def _on_config_changed(self, event: ops.framework.EventBase) -> None:
+        """Handle the config changed event."""
+        if not self._stored.gunicorn_pebble_ready:
+            logger.info(
+                "Got a config changed event, but the workload isn't ready yet. Doing nothing, config will be "
+                "picked up when workload is ready."
+            )
+            return
+
+        pebble_config = self._get_pebble_config(event)
+        if not pebble_config:
+            # Charm will be in blocked status.
+            return
+
+        # Ensure the ingress relation has the external hostname.
+        self.ingress.update_config({"service-hostname": self.config["external_hostname"]})
+
+        container = self.unit.get_container("gunicorn")
+        plan = container.get_plan().to_dict()
+        if plan["services"] != pebble_config["services"]:
+            container.add_layer("gunicorn", pebble_config, combine=True)
+
+            status = container.get_service("gunicorn")
+            if status.current == ServiceStatus.ACTIVE:
+                container.stop("gunicorn")
+            container.start("gunicorn")
+
+        self.unit.status = ActiveStatus()
+
+    def _on_upgrade_charm(self, event: ops.framework.EventBase) -> None:
+        """Handle the upgrade charm event."""
+        # An 'upgrade-charm' hook (which will also be triggered by an
+        # 'attach-resource' event) will cause the pod to be rescheduled:
+        # even though the name remains the same, the IP may change.
+        # The workload won't be running, so we need to handle that in the
+        # course of subsequent events that will be triggered after this.
+        #
+        # Setting pebble_ready to `False` will ensure a 'config-changed'
+        # hook waits for the workload to be ready before doing anything.
+        self._stored.gunicorn_pebble_ready = False
+        # An upgrade-charm hook will be followed by others such as config-changed
+        # and workload-ready, so just do nothing else for now.
+        return
+
+    def _on_gunicorn_pebble_ready(self, event: ops.framework.EventBase) -> None:
+        """Handle the workload ready event."""
+        self._stored.gunicorn_pebble_ready = True
+
+        pebble_config = self._get_pebble_config(event)
+        if not pebble_config:
+            # Charm will be in blocked status.
+            return
+
+        container = event.workload
+        logger.debug("About to add_layer with pebble_config:\n{}".format(yaml.dump(pebble_config)))
+        # `container.add_layer` accepts str (YAML) or dict or pebble.Layer
+        # object directly.
+        container.add_layer("gunicorn", pebble_config)
+        # Start the container and set status.
+        container.autostart()
+        self.unit.status = ActiveStatus()
+
     def _init_postgresql_relation(self) -> None:
         """Initialization related to the postgresql relation"""
         if 'pg' not in self._stored.reldata:
@@ -118,38 +235,6 @@ class GunicornK8sCharm(CharmBase):
                 "Required Juju config item(s) not set : {}".format(", ".join(sorted(errors)))
             )
 
-    def _make_k8s_ingress(self) -> list:
-        """Return an ingress that you can use in k8s_resources
-
-        :returns: A list to be used as k8s ingress
-        """
-
-        hostname = self.model.config['external_hostname']
-
-        ingress = {
-            "name": "{}-ingress".format(self.app.name),
-            "spec": {
-                "rules": [
-                    {
-                        "host": hostname,
-                        "http": {
-                            "paths": [
-                                {
-                                    "path": "/",
-                                    "backend": {"serviceName": self.app.name, "servicePort": 80},
-                                }
-                            ]
-                        },
-                    }
-                ]
-            },
-            "annotations": {
-                'nginx.ingress.kubernetes.io/ssl-redirect': 'false',
-            },
-        }
-
-        return [ingress]
-
     def _render_template(self, tmpl: str, ctx: dict) -> str:
         """Render a Jinja2 template
 
@@ -243,6 +328,7 @@ class GunicornK8sCharm(CharmBase):
             return {}
 
         ctx = self._get_context_from_relations()
+<<<<<<< src/charm.py
         rendered_env = self._render_template(env, ctx)
 
         try:
@@ -300,6 +386,8 @@ class GunicornK8sCharm(CharmBase):
         env = self.model.config['environment']
         ctx = self._get_context_from_relations()
 
+=======
+>>>>>>> src/charm.py
         if env:
             j2env = Environment(loader=BaseLoader)
             j2template = j2env.parse(env)
@@ -310,40 +398,22 @@ class GunicornK8sCharm(CharmBase):
                     missing_vars.add(req_var)
 
             if missing_vars:
-                logger.info(
-                    "Missing YAML vars to interpolate the 'environment' config option, "
-                    "setting status to 'waiting' : %s",
-                    ", ".join(sorted(missing_vars)),
+                raise GunicornK8sWaitingForRelationsError(
+                    'Waiting for {} relation(s)'.format(", ".join(sorted(missing_vars)))
                 )
-                self.unit.status = BlockedStatus('Waiting for {} relation(s)'.format(", ".join(sorted(missing_vars))))
-                event.defer()
-                return
-
-        if not self.unit.is_leader():
-            self.unit.status = ActiveStatus()
-            return
 
-        try:
-            self._check_juju_config()
-        except GunicornK8sCharmJujuConfigError as e:
-            self.unit.status = BlockedStatus(str(e))
-            return
-
-        self.unit.status = MaintenanceStatus('Assembling pod spec')
+        rendered_env = self._render_template(env, ctx)
 
         try:
-            pod_spec = self._make_pod_spec()
-        except GunicornK8sCharmJujuConfigError as e:
-            self.unit.status = BlockedStatus(str(e))
-            return
+            self._validate_yaml(rendered_env, dict)
+        except GunicornK8sCharmYAMLError:
+            raise GunicornK8sCharmJujuConfigError(
+                "Could not parse Juju config 'environment' as a YAML dict - check \"juju debug-log -l ERROR\""
+            )
 
-        resources = pod_spec.get('kubernetesResources', {})
-        resources['ingressResources'] = self._make_k8s_ingress()
+        env = yaml.safe_load(rendered_env)
 
-        self.unit.status = MaintenanceStatus('Setting pod spec')
-        self.model.pod.set_spec(pod_spec, k8s_resources={'kubernetesResources': resources})
-        logger.info("Setting active status")
-        self.unit.status = ActiveStatus()
+        return env
 
 
 if __name__ == "__main__":  # pragma: no cover
diff --git a/tests/unit/scenario.py b/tests/unit/scenario.py
index 3402589..f695a2e 100644
--- a/tests/unit/scenario.py
+++ b/tests/unit/scenario.py
@@ -78,6 +78,7 @@ TEST_CONFIGURE_POD = {
     },
 }
 
+<<<<<<< tests/unit/scenario.py
 TEST_MAKE_POD_SPEC = {
     'basic_no_env': {
         'config': {
@@ -158,6 +159,8 @@ TEST_MAKE_K8S_INGRESS = {
     },
 }
 
+=======
+>>>>>>> tests/unit/scenario.py
 TEST_RENDER_TEMPLATE = {
     'working': {
         'tmpl': "test {{db.x}}",
diff --git a/tests/unit/test_charm.py b/tests/unit/test_charm.py
index b5e1f87..4572910 100755
--- a/tests/unit/test_charm.py
+++ b/tests/unit/test_charm.py
@@ -18,8 +18,6 @@ from scenario import (
     JUJU_DEFAULT_CONFIG,
     TEST_JUJU_CONFIG,
     TEST_CONFIGURE_POD,
-    TEST_MAKE_POD_SPEC,
-    TEST_MAKE_K8S_INGRESS,
     TEST_RENDER_TEMPLATE,
     TEST_PG_URI,
     TEST_PG_CONNSTR,
@@ -161,16 +159,6 @@ class TestGunicornK8sCharm(unittest.TestCase):
                 # The second argument is the list of key to reset
                 self.harness.update_config(JUJU_DEFAULT_CONFIG)
 
-    def test_make_k8s_ingress(self):
-        """Check the crafting of the ingress part of the pod spec."""
-        self.harness.update_config(JUJU_DEFAULT_CONFIG)
-
-        for scenario, values in TEST_MAKE_K8S_INGRESS.items():
-            with self.subTest(scenario=scenario):
-                self.harness.update_config(values['config'])
-                self.assertEqual(self.harness.charm._make_k8s_ingress(), values['expected'])
-                self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
-
     def test_render_template(self):
         """Test template rendering."""
 
@@ -406,16 +394,6 @@ class TestGunicornK8sCharm(unittest.TestCase):
 
         self.assertEqual(self.harness.charm.unit.status, BlockedStatus(expected_status))
 
-    def test_make_pod_spec(self):
-        """Check the crafting of the pod spec."""
-        self.harness.update_config(JUJU_DEFAULT_CONFIG)
-
-        for scenario, values in TEST_MAKE_POD_SPEC.items():
-            with self.subTest(scenario=scenario):
-                self.harness.update_config(values['config'])
-                self.assertEqual(self.harness.charm._make_pod_spec(), values['pod_spec'])
-                self.harness.update_config(JUJU_DEFAULT_CONFIG)  # You need to clean the config after each run
-
 
 if __name__ == '__main__':
     unittest.main()