Bug 1995 fixed: possibility of defining the K8s namespace for Juju Bundles

Now, N2VC will use the namespace passed by argument to the methods
install and get_services. Also added this argument to other functions
where it should be passed. When it is not passed, for now it is obtained
from the nsrs, but it should be always passed to avoid queries to the
database, while mainaining backward compatibility.
Updated the N2VC tests accordingly.

Change-Id: Iace944506ba212034efdbb87c6f2d74f8265ea4e
Signed-off-by: Pedro Escaleira <escaleira@av.it.pt>

diff --git a/n2vc/k8s_juju_conn.py b/n2vc/k8s_juju_conn.py
index 99e868b..396d79b 100644 (file)
--- a/n2vc/k8s_juju_conn.py
+++ b/n2vc/k8s_juju_conn.py
@@ -327,12 +327,16 @@ class K8sJujuConnector(K8sConnector):
             os.chdir(new_workdir)
             bundle = "local:{}".format(kdu_model)
 
-        self.log.debug("Checking for model named {}".format(kdu_instance))
+        # default namespace to kdu_instance
+        if not namespace:
+            namespace = kdu_instance
+
+        self.log.debug("Checking for model named {}".format(namespace))
 
         # Create the new model
-        self.log.debug("Adding model: {}".format(kdu_instance))
+        self.log.debug("Adding model: {}".format(namespace))
         cloud = Cloud(cluster_uuid, self._get_credential_name(cluster_uuid))
-        await libjuju.add_model(kdu_instance, cloud)
+        await libjuju.add_model(namespace, cloud)
 
         # if model:
         # TODO: Instantiation parameters
@@ -351,10 +355,10 @@ class K8sJujuConnector(K8sConnector):
             previous_workdir = "/app/storage"
 
         self.log.debug("[install] deploying {}".format(bundle))
-        await libjuju.deploy(
-            bundle, model_name=kdu_instance, wait=atomic, timeout=timeout
-        )
+        await libjuju.deploy(bundle, model_name=namespace, wait=atomic, timeout=timeout)
         os.chdir(previous_workdir)
+
+        # update information in the database (first, the VCA status, and then, the namespace)
         if self.on_update_db:
             await self.on_update_db(
                 cluster_uuid,
@@ -362,6 +366,13 @@ class K8sJujuConnector(K8sConnector):
                 filter=db_dict["filter"],
                 vca_id=kwargs.get("vca_id"),
             )
+
+        self.db.set_one(
+            table="nsrs",
+            q_filter={"_admin.deployed.K8s.kdu-instance": kdu_instance},
+            update_dict={"_admin.deployed.K8s.$.namespace": namespace},
+        )
+
         return True
 
     async def scale(
@@ -370,6 +381,7 @@ class K8sJujuConnector(K8sConnector):
         scale: int,
         resource_name: str,
         total_timeout: float = 1800,
+        namespace: str = None,
         **kwargs,
     ) -> bool:
         """Scale an application in a model
@@ -379,23 +391,27 @@ class K8sJujuConnector(K8sConnector):
         :param: resource_name str:       The application name in the Juju Bundle
         :param: timeout float:           The time, in seconds, to wait for the install
                                          to finish
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs:                   Additional parameters
                                             vca_id (str): VCA ID
 
         :return: If successful, returns True
         """
 
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
         try:
             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
             await libjuju.scale_application(
-                model_name=kdu_instance,
+                model_name=model_name,
                 application_name=resource_name,
                 scale=scale,
                 total_timeout=total_timeout,
             )
         except Exception as e:
-            error_msg = "Error scaling application {} in kdu instance {}: {}".format(
-                resource_name, kdu_instance, e
+            error_msg = "Error scaling application {} of the model {} of the kdu instance {}: {}".format(
+                resource_name, model_name, kdu_instance, e
             )
             self.log.error(error_msg)
             raise K8sException(message=error_msg)
@@ -405,24 +421,30 @@ class K8sJujuConnector(K8sConnector):
         self,
         resource_name: str,
         kdu_instance: str,
+        namespace: str = None,
         **kwargs,
     ) -> int:
         """Get an application scale count
 
         :param: resource_name str:       The application name in the Juju Bundle
         :param: kdu_instance str:        KDU instance name
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs:                   Additional parameters
                                             vca_id (str): VCA ID
         :return: Return application instance count
         """
 
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
         try:
             libjuju = await self._get_libjuju(kwargs.get("vca_id"))
-            status = await libjuju.get_model_status(kdu_instance)
+            status = await libjuju.get_model_status(model_name=model_name)
             return len(status.applications[resource_name].units)
         except Exception as e:
-            error_msg = "Error getting scale count from application {} in kdu instance {}: {}".format(
-                resource_name, kdu_instance, e
+            error_msg = (
+                f"Error getting scale count from application {resource_name} of the model {model_name} of "
+                f"the kdu instance {kdu_instance}: {e}"
             )
             self.log.error(error_msg)
             raise K8sException(message=error_msg)
@@ -495,42 +517,47 @@ class K8sJujuConnector(K8sConnector):
         self,
         cluster_uuid: str,
         kdu_instance: str,
+        namespace: str = None,
         **kwargs,
     ) -> bool:
         """Uninstall a KDU instance
 
         :param cluster_uuid str: The UUID of the cluster
         :param kdu_instance str: The unique name of the KDU instance
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs: Additional parameters
             vca_id (str): VCA ID
 
         :return: Returns True if successful, or raises an exception
         """
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
 
-        self.log.debug("[uninstall] Destroying model")
+        self.log.debug(f"[uninstall] Destroying model: {model_name}")
 
         will_not_delete = False
-        if kdu_instance not in self.uninstall_locks:
-            self.uninstall_locks[kdu_instance] = asyncio.Lock(loop=self.loop)
-        delete_lock = self.uninstall_locks[kdu_instance]
+        if model_name not in self.uninstall_locks:
+            self.uninstall_locks[model_name] = asyncio.Lock(loop=self.loop)
+        delete_lock = self.uninstall_locks[model_name]
 
         while delete_lock.locked():
             will_not_delete = True
             await asyncio.sleep(0.1)
 
         if will_not_delete:
-            self.log.info("Model {} deleted by another worker.".format(kdu_instance))
+            self.log.info("Model {} deleted by another worker.".format(model_name))
             return True
 
         try:
             async with delete_lock:
                 libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 
-                await libjuju.destroy_model(kdu_instance, total_timeout=3600)
+                await libjuju.destroy_model(model_name, total_timeout=3600)
         finally:
-            self.uninstall_locks.pop(kdu_instance)
+            self.uninstall_locks.pop(model_name)
 
-        self.log.debug(f"[uninstall] Model {kdu_instance} destroyed")
+        self.log.debug(f"[uninstall] Model {model_name} destroyed")
         return True
 
     async def upgrade_charm(
@@ -565,6 +592,7 @@ class K8sJujuConnector(K8sConnector):
         timeout: float = 300,
         params: dict = None,
         db_dict: dict = None,
+        namespace: str = None,
         **kwargs,
     ) -> str:
         """Exec primitive (Juju action)
@@ -575,6 +603,7 @@ class K8sJujuConnector(K8sConnector):
         :param timeout: Timeout for action execution
         :param params: Dictionary of all the parameters needed for the action
         :param db_dict: Dictionary for any additional data
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param kwargs: Additional parameters
             vca_id (str): VCA ID
 
@@ -582,6 +611,10 @@ class K8sJujuConnector(K8sConnector):
         """
         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
 
+        namespace = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+
         if not params or "application-name" not in params:
             raise K8sException(
                 "Missing application-name argument, \
@@ -590,14 +623,19 @@ class K8sJujuConnector(K8sConnector):
         try:
             self.log.debug(
                 "[exec_primitive] Getting model "
-                "kdu_instance: {}".format(kdu_instance)
+                "{} for the kdu_instance: {}".format(namespace, kdu_instance)
             )
             application_name = params["application-name"]
-            actions = await libjuju.get_actions(application_name, kdu_instance)
+            actions = await libjuju.get_actions(
+                application_name=application_name, model_name=namespace
+            )
             if primitive_name not in actions:
                 raise K8sException("Primitive {} not found".format(primitive_name))
             output, status = await libjuju.execute_action(
-                application_name, kdu_instance, primitive_name, **params
+                application_name=application_name,
+                model_name=namespace,
+                action_name=primitive_name,
+                **params,
             )
 
             if status != "completed":
@@ -606,7 +644,9 @@ class K8sJujuConnector(K8sConnector):
                 )
             if self.on_update_db:
                 await self.on_update_db(
-                    cluster_uuid, kdu_instance, filter=db_dict["filter"]
+                    cluster_uuid=cluster_uuid,
+                    kdu_instance=kdu_instance,
+                    filter=db_dict["filter"],
                 )
 
             return output
@@ -669,11 +709,11 @@ class K8sJujuConnector(K8sConnector):
     ) -> str:
         """View the README
 
-        If available, returns the README of the bundle.
+                If available, returns the README of the bundle.
 
-        :param kdu_model str: The name or path of a bundle
-
-        :return: If found, returns the contents of the README.
+                :param kdu_model str: The name or path of a bundle
+        f
+                :return: If found, returns the contents of the README.
         """
         readme = None
 
@@ -693,6 +733,7 @@ class K8sJujuConnector(K8sConnector):
         kdu_instance: str,
         complete_status: bool = False,
         yaml_format: bool = False,
+        namespace: str = None,
         **kwargs,
     ) -> Union[str, dict]:
         """Get the status of the KDU
@@ -703,6 +744,7 @@ class K8sJujuConnector(K8sConnector):
         :param kdu_instance str: The unique id of the KDU instance
         :param complete_status: To get the complete_status of the KDU
         :param yaml_format: To get the status in proper format for NSR record
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param: kwargs: Additional parameters
             vca_id (str): VCA ID
 
@@ -712,7 +754,10 @@ class K8sJujuConnector(K8sConnector):
         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
         status = {}
 
-        model_status = await libjuju.get_model_status(kdu_instance)
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+        model_status = await libjuju.get_model_status(model_name=model_name)
 
         if not complete_status:
             for name in model_status.applications:
@@ -773,32 +818,44 @@ class K8sJujuConnector(K8sConnector):
             self.log.error(message)
             raise Exception(message=message)
 
-    async def update_vca_status(self, vcastatus: dict, kdu_instance: str, **kwargs):
+    async def update_vca_status(
+        self, vcastatus: dict, kdu_instance: str, namespace: str = None, **kwargs
+    ):
         """
         Add all configs, actions, executed actions of all applications in a model to vcastatus dict
 
         :param vcastatus dict: dict containing vcastatus
         :param kdu_instance str: The unique id of the KDU instance
+        :param namespace str: The namespace (model) where the Bundle was deployed
         :param: kwargs: Additional parameters
             vca_id (str): VCA ID
 
         :return: None
         """
+
+        model_name = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+
         libjuju = await self._get_libjuju(kwargs.get("vca_id"))
         try:
-            for model_name in vcastatus:
+            for vca_model_name in vcastatus:
                 # Adding executed actions
-                vcastatus[model_name][
+                vcastatus[vca_model_name][
                     "executedActions"
-                ] = await libjuju.get_executed_actions(kdu_instance)
+                ] = await libjuju.get_executed_actions(model_name=model_name)
 
-                for application in vcastatus[model_name]["applications"]:
+                for application in vcastatus[vca_model_name]["applications"]:
                     # Adding application actions
-                    vcastatus[model_name]["applications"][application]["actions"] = {}
+                    vcastatus[vca_model_name]["applications"][application][
+                        "actions"
+                    ] = {}
                     # Adding application configs
-                    vcastatus[model_name]["applications"][application][
+                    vcastatus[vca_model_name]["applications"][application][
                         "configs"
-                    ] = await libjuju.get_application_configs(kdu_instance, application)
+                    ] = await libjuju.get_application_configs(
+                        model_name=model_name, application_name=application
+                    )
 
         except Exception as e:
             self.log.debug("Error in updating vca status: {}".format(str(e)))
@@ -808,10 +865,14 @@ class K8sJujuConnector(K8sConnector):
     ) -> list:
         """Return a list of services of a kdu_instance"""
 
+        namespace = self._obtain_namespace(
+            kdu_instance=kdu_instance, namespace=namespace
+        )
+
         credentials = self.get_credentials(cluster_uuid=cluster_uuid)
         kubectl = self._get_kubectl(credentials)
         return kubectl.get_services(
-            field_selector="metadata.namespace={}".format(kdu_instance)
+            field_selector="metadata.namespace={}".format(namespace)
         )
 
     async def get_service(
@@ -917,3 +978,34 @@ class K8sJujuConnector(K8sConnector):
         with open(kubecfg.name, "w") as kubecfg_file:
             kubecfg_file.write(credentials)
         return Kubectl(config_file=kubecfg.name)
+
+    def _obtain_namespace(self, kdu_instance: str, namespace: str = None) -> str:
+        """
+        Obtain the namespace/model name to use in the instantiation of a Juju Bundle in K8s. The default namespace is
+        the kdu_instance name. However, if the user passes the namespace where he wants to deploy the bundle,
+        that namespace will be used.
+
+        :param kdu_instance: the default KDU instance name
+        :param namespace: the namespace passed by the User
+        """
+
+        # deault the namespace/model name to the kdu_instance name TODO -> this should be the real return... But
+        #  once the namespace is not passed in most methods, I had to do this in another way. But I think this should
+        #  be the procedure in the future return namespace if namespace else kdu_instance
+
+        # TODO -> has referred above, this should be avoided in the future, this is temporary, in order to avoid
+        #  compatibility issues
+        return (
+            namespace
+            if namespace
+            else self._obtain_namespace_from_db(kdu_instance=kdu_instance)
+        )
+
+    def _obtain_namespace_from_db(self, kdu_instance: str) -> str:
+        db_nsrs = self.db.get_one(
+            table="nsrs", q_filter={"_admin.deployed.K8s.kdu-instance": kdu_instance}
+        )
+        for k8s in db_nsrs["_admin"]["deployed"]["K8s"]:
+            if k8s.get("kdu-instance") == kdu_instance:
+                return k8s.get("namespace")
+        return ""

diff --git a/n2vc/tests/unit/test_k8s_juju_conn.py b/n2vc/tests/unit/test_k8s_juju_conn.py
index 915738e..3e35494 100644 (file)
--- a/n2vc/tests/unit/test_k8s_juju_conn.py
+++ b/n2vc/tests/unit/test_k8s_juju_conn.py
@@ -67,6 +67,10 @@ class K8sJujuConnTestCase(asynctest.TestCase):
         )
         logging.disable(logging.CRITICAL)
 
+        self.kdu_name = "kdu_name"
+        self.kdu_instance = "{}-{}".format(self.kdu_name, "id")
+        self.default_namespace = self.kdu_instance
+
         self.k8s_juju_conn = K8sJujuConnector(
             fs=fslocal.FsLocal(),
             db=self.db,
@@ -83,6 +87,9 @@ class K8sJujuConnTestCase(asynctest.TestCase):
         self.kubectl.get_services.return_value = [{}]
         self.k8s_juju_conn._get_kubectl = Mock()
         self.k8s_juju_conn._get_kubectl.return_value = self.kubectl
+        self.k8s_juju_conn._obtain_namespace_from_db = Mock(
+            return_value=self.default_namespace
+        )
 
 
 class InitEnvTest(K8sJujuConnTestCase):
@@ -203,9 +210,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.local_bundle = "bundle"
         self.cs_bundle = "cs:bundle"
         self.http_bundle = "https://example.com/bundle.yaml"
-        self.kdu_name = "kdu_name"
         self.cluster_uuid = "cluster"
-        self.kdu_instance = "{}-{}".format(self.kdu_name, "id")
         self.k8s_juju_conn.libjuju.add_model = AsyncMock()
         self.k8s_juju_conn.libjuju.deploy = AsyncMock()
 
@@ -225,7 +230,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.k8s_juju_conn.libjuju.add_model.assert_called_once()
         self.k8s_juju_conn.libjuju.deploy.assert_called_once_with(
             "local:{}".format(self.local_bundle),
-            model_name=self.kdu_instance,
+            model_name=self.default_namespace,
             wait=True,
             timeout=1800,
         )
@@ -245,7 +250,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.k8s_juju_conn.libjuju.add_model.assert_called_once()
         self.k8s_juju_conn.libjuju.deploy.assert_called_once_with(
             self.cs_bundle,
-            model_name=self.kdu_instance,
+            model_name=self.default_namespace,
             wait=True,
             timeout=1800,
         )
@@ -265,7 +270,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.k8s_juju_conn.libjuju.add_model.assert_called_once()
         self.k8s_juju_conn.libjuju.deploy.assert_called_once_with(
             self.http_bundle,
-            model_name=self.kdu_instance,
+            model_name=self.default_namespace,
             wait=True,
             timeout=1800,
         )
@@ -284,7 +289,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.k8s_juju_conn.libjuju.add_model.assert_called_once()
         self.k8s_juju_conn.libjuju.deploy.assert_called_once_with(
             self.cs_bundle,
-            model_name=self.kdu_instance,
+            model_name=self.default_namespace,
             wait=True,
             timeout=1800,
         )
@@ -323,7 +328,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.k8s_juju_conn.libjuju.add_model.assert_called_once()
         self.k8s_juju_conn.libjuju.deploy.assert_called_once_with(
             self.cs_bundle,
-            model_name=self.kdu_instance,
+            model_name=self.default_namespace,
             wait=True,
             timeout=1800,
         )
@@ -361,7 +366,7 @@ class InstallTest(K8sJujuConnTestCase):
         self.k8s_juju_conn.libjuju.add_model.assert_called_once()
         self.k8s_juju_conn.libjuju.deploy.assert_called_once_with(
             "local:{}".format(self.local_bundle),
-            model_name=self.kdu_instance,
+            model_name=self.default_namespace,
             wait=True,
             timeout=1800,
         )
@@ -395,7 +400,6 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
         super(ExecPrimitivesTest, self).setUp()
         self.action_name = "touch"
         self.application_name = "myapp"
-        self.model_name = "model"
         self.k8s_juju_conn.libjuju.get_actions = AsyncMock()
         self.k8s_juju_conn.libjuju.execute_action = AsyncMock()
 
@@ -409,16 +413,22 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
 
         output = self.loop.run_until_complete(
             self.k8s_juju_conn.exec_primitive(
-                "cluster", self.model_name, self.action_name, params=params
+                "cluster", self.kdu_instance, self.action_name, params=params
             )
         )
 
         self.assertEqual(output, "success")
+        self.k8s_juju_conn._obtain_namespace_from_db.assert_called_once_with(
+            kdu_instance=self.kdu_instance
+        )
         self.k8s_juju_conn.libjuju.get_actions.assert_called_once_with(
-            self.application_name, self.model_name
+            application_name=self.application_name, model_name=self.default_namespace
         )
         self.k8s_juju_conn.libjuju.execute_action.assert_called_once_with(
-            self.application_name, self.model_name, self.action_name, **params
+            application_name=self.application_name,
+            model_name=self.default_namespace,
+            action_name=self.action_name,
+            **params
         )
 
     def test_exception(self):
@@ -430,16 +440,22 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
         with self.assertRaises(Exception):
             output = self.loop.run_until_complete(
                 self.k8s_juju_conn.exec_primitive(
-                    "cluster", self.model_name, self.action_name, params=params
+                    "cluster", self.kdu_instance, self.action_name, params=params
                 )
             )
 
         self.assertIsNone(output)
+        self.k8s_juju_conn._obtain_namespace_from_db.assert_called_once_with(
+            kdu_instance=self.kdu_instance
+        )
         self.k8s_juju_conn.libjuju.get_actions.assert_called_once_with(
-            self.application_name, self.model_name
+            application_name=self.application_name, model_name=self.default_namespace
         )
         self.k8s_juju_conn.libjuju.execute_action.assert_called_once_with(
-            self.application_name, self.model_name, self.action_name, **params
+            application_name=self.application_name,
+            model_name=self.default_namespace,
+            action_name=self.action_name,
+            **params
         )
 
     def test_missing_application_name_in_params(self):
@@ -449,7 +465,7 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
         with self.assertRaises(K8sException):
             output = self.loop.run_until_complete(
                 self.k8s_juju_conn.exec_primitive(
-                    "cluster", self.model_name, self.action_name, params=params
+                    "cluster", self.kdu_instance, self.action_name, params=params
                 )
             )
 
@@ -462,7 +478,7 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
         with self.assertRaises(K8sException):
             output = self.loop.run_until_complete(
                 self.k8s_juju_conn.exec_primitive(
-                    "cluster", self.model_name, self.action_name
+                    "cluster", self.kdu_instance, self.action_name
                 )
             )
 
@@ -481,13 +497,16 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
         with self.assertRaises(K8sException):
             output = self.loop.run_until_complete(
                 self.k8s_juju_conn.exec_primitive(
-                    "cluster", self.model_name, "non-existing-action", params=params
+                    "cluster", self.kdu_instance, "non-existing-action", params=params
                 )
             )
 
         self.assertIsNone(output)
+        self.k8s_juju_conn._obtain_namespace_from_db.assert_called_once_with(
+            kdu_instance=self.kdu_instance
+        )
         self.k8s_juju_conn.libjuju.get_actions.assert_called_once_with(
-            self.application_name, self.model_name
+            application_name=self.application_name, model_name=self.default_namespace
         )
         self.k8s_juju_conn.libjuju.execute_action.assert_not_called()
 
@@ -499,16 +518,22 @@ class ExecPrimitivesTest(K8sJujuConnTestCase):
         with self.assertRaises(K8sException):
             output = self.loop.run_until_complete(
                 self.k8s_juju_conn.exec_primitive(
-                    "cluster", self.model_name, self.action_name, params=params
+                    "cluster", self.kdu_instance, self.action_name, params=params
                 )
             )
 
         self.assertIsNone(output)
+        self.k8s_juju_conn._obtain_namespace_from_db.assert_called_once_with(
+            kdu_instance=self.kdu_instance
+        )
         self.k8s_juju_conn.libjuju.get_actions.assert_called_once_with(
-            self.application_name, self.model_name
+            application_name=self.application_name, model_name=self.default_namespace
         )
         self.k8s_juju_conn.libjuju.execute_action.assert_called_once_with(
-            self.application_name, self.model_name, self.action_name, **params
+            application_name=self.application_name,
+            model_name=self.default_namespace,
+            action_name=self.action_name,
+            **params
         )
 
 
@@ -647,8 +672,6 @@ class UpdateVcaStatusTest(K8sJujuConnTestCase):
     def setUp(self):
         super(UpdateVcaStatusTest, self).setUp()
         self.vcaStatus = {"model": {"applications": {"app": {"actions": {}}}}}
-        self.kdu_name = "kdu_name"
-        self.kdu_instance = "{}-{}".format(self.kdu_name, "id")
         self.k8s_juju_conn.libjuju.get_executed_actions = AsyncMock()
         self.k8s_juju_conn.libjuju.get_actions = AsyncMock()
         self.k8s_juju_conn.libjuju.get_application_configs = AsyncMock()