projects / osm / N2VC.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Support for helm v3
[osm/N2VC.git] / n2vc / tests / unit / test_libjuju.py
diff --git a/n2vc/tests/unit/test_libjuju.py b/n2vc/tests/unit/test_libjuju.py
index 8c16c9d..7bea6b3 100644 (file)
--- a/n2vc/tests/unit/test_libjuju.py
+++ b/n2vc/tests/unit/test_libjuju.py
@@ -30,6 +30,7 @@ from n2vc.exceptions import (
     JujuActionNotFound,
     JujuApplicationExists,
     JujuInvalidK8sConfiguration,
     JujuActionNotFound,
     JujuApplicationExists,
     JujuInvalidK8sConfiguration,
+    JujuLeaderUnitNotFound,
 )
 
 
 )
 
 
@@ -72,6 +73,91 @@ class LibjujuTestCase(asynctest.TestCase):
         loop.run_until_complete(self.libjuju.disconnect())
 
 
         loop.run_until_complete(self.libjuju.disconnect())
 
 
+@asynctest.mock.patch("n2vc.libjuju.Libjuju._create_health_check_task")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju._update_api_endpoints_db")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_api_endpoints_db")
+class LibjujuInitTestCase(asynctest.TestCase):
+    def setUp(self):
+        self.loop = asyncio.get_event_loop()
+        self.n2vc = FakeN2VC()
+        self.endpoint = "192.168.100.100:17070"
+        self.username = "admin"
+        self.password = "secret"
+        self.cacert = """
+    -----BEGIN CERTIFICATE-----
+    SOMECERT
+    -----END CERTIFICATE-----"""
+
+    def test_endpoint_not_in_db(
+        self,
+        mock__get_api_endpoints_db,
+        mock_update_endpoints,
+        mock_create_health_check_task,
+    ):
+        mock__get_api_endpoints_db.return_value = ["another_ip"]
+        Libjuju(
+            self.endpoint,
+            "192.168.0.155:17070",
+            self.username,
+            self.password,
+            self.cacert,
+            self.loop,
+            log=None,
+            db={"get_one": []},
+            n2vc=self.n2vc,
+            apt_mirror="192.168.0.100",
+            enable_os_upgrade=True,
+        )
+        mock_update_endpoints.assert_called_once_with([self.endpoint])
+        mock__get_api_endpoints_db.assert_called_once()
+
+    def test_endpoint_in_db(
+        self,
+        mock__get_api_endpoints_db,
+        mock_update_endpoints,
+        mock_create_health_check_task,
+    ):
+        mock__get_api_endpoints_db.return_value = [self.endpoint, "another_ip"]
+        Libjuju(
+            self.endpoint,
+            "192.168.0.155:17070",
+            self.username,
+            self.password,
+            self.cacert,
+            self.loop,
+            log=None,
+            db={"get_one": []},
+            n2vc=self.n2vc,
+            apt_mirror="192.168.0.100",
+            enable_os_upgrade=True,
+        )
+        mock_update_endpoints.assert_not_called()
+        mock__get_api_endpoints_db.assert_called_once()
+
+    def test_no_db_endpoints(
+        self,
+        mock__get_api_endpoints_db,
+        mock_update_endpoints,
+        mock_create_health_check_task,
+    ):
+        mock__get_api_endpoints_db.return_value = None
+        Libjuju(
+            self.endpoint,
+            "192.168.0.155:17070",
+            self.username,
+            self.password,
+            self.cacert,
+            self.loop,
+            log=None,
+            db={"get_one": []},
+            n2vc=self.n2vc,
+            apt_mirror="192.168.0.100",
+            enable_os_upgrade=True,
+        )
+        mock_update_endpoints.assert_called_once_with([self.endpoint])
+        mock__get_api_endpoints_db.assert_called_once()
+
+
 @asynctest.mock.patch("juju.controller.Controller.connect")
 @asynctest.mock.patch(
     "juju.controller.Controller.api_endpoints",
 @asynctest.mock.patch("juju.controller.Controller.connect")
 @asynctest.mock.patch(
     "juju.controller.Controller.api_endpoints",
@@ -186,7 +272,8 @@ class GetModelTest(LibjujuTestCase):
         super(GetModelTest, self).setUp()
 
     def test_get_model(
         super(GetModelTest, self).setUp()
 
     def test_get_model(
-        self, mock_get_model,
+        self,
+        mock_get_model,
     ):
         mock_get_model.return_value = juju.model.Model()
         model = self.loop.run_until_complete(
     ):
         mock_get_model.return_value = juju.model.Model()
         model = self.loop.run_until_complete(
@@ -202,7 +289,9 @@ class ModelExistsTest(LibjujuTestCase):
         super(ModelExistsTest, self).setUp()
 
     async def test_existing_model(
         super(ModelExistsTest, self).setUp()
 
     async def test_existing_model(
-        self, mock_list_models, mock_get_controller,
+        self,
+        mock_list_models,
+        mock_get_controller,
     ):
         mock_list_models.return_value = ["existing_model"]
         self.assertTrue(
     ):
         mock_list_models.return_value = ["existing_model"]
         self.assertTrue(
@@ -213,7 +302,10 @@ class ModelExistsTest(LibjujuTestCase):
 
     @asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_controller")
     async def test_no_controller(
 
     @asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_controller")
     async def test_no_controller(
-        self, mock_disconnect_controller, mock_list_models, mock_get_controller,
+        self,
+        mock_disconnect_controller,
+        mock_list_models,
+        mock_get_controller,
     ):
         mock_list_models.return_value = ["existing_model"]
         mock_get_controller.return_value = juju.controller.Controller()
     ):
         mock_list_models.return_value = ["existing_model"]
         mock_get_controller.return_value = juju.controller.Controller()
@@ -221,7 +313,9 @@ class ModelExistsTest(LibjujuTestCase):
         mock_disconnect_controller.assert_called_once()
 
     async def test_non_existing_model(
         mock_disconnect_controller.assert_called_once()
 
     async def test_non_existing_model(
-        self, mock_list_models, mock_get_controller,
+        self,
+        mock_list_models,
+        mock_get_controller,
     ):
         mock_list_models.return_value = ["existing_model"]
         self.assertFalse(
     ):
         mock_list_models.return_value = ["existing_model"]
         self.assertFalse(
@@ -367,6 +461,71 @@ class CreateMachineTest(LibjujuTestCase):
 # TODO test provision machine
 
 
 # TODO test provision machine
 
 
+@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_model")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_model")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_controller")
+@asynctest.mock.patch("n2vc.juju_watcher.JujuModelWatcher.wait_for_model")
+@asynctest.mock.patch("juju.model.Model.deploy")
+class DeployTest(LibjujuTestCase):
+    def setUp(self):
+        super(DeployTest, self).setUp()
+
+    def test_deploy(
+        self,
+        mock_deploy,
+        mock_wait_for_model,
+        mock_disconnect_controller,
+        mock_disconnect_model,
+        mock_get_model,
+        mock_get_controller,
+    ):
+        mock_get_model.return_value = juju.model.Model()
+        self.loop.run_until_complete(
+            self.libjuju.deploy("cs:osm", "model", wait=True, timeout=0)
+        )
+        mock_deploy.assert_called_once()
+        mock_wait_for_model.assert_called_once()
+        mock_disconnect_controller.assert_called_once()
+        mock_disconnect_model.assert_called_once()
+
+    def test_deploy_no_wait(
+        self,
+        mock_deploy,
+        mock_wait_for_model,
+        mock_disconnect_controller,
+        mock_disconnect_model,
+        mock_get_model,
+        mock_get_controller,
+    ):
+        mock_get_model.return_value = juju.model.Model()
+        self.loop.run_until_complete(
+            self.libjuju.deploy("cs:osm", "model", wait=False, timeout=0)
+        )
+        mock_deploy.assert_called_once()
+        mock_wait_for_model.assert_not_called()
+        mock_disconnect_controller.assert_called_once()
+        mock_disconnect_model.assert_called_once()
+
+    def test_deploy_exception(
+        self,
+        mock_deploy,
+        mock_wait_for_model,
+        mock_disconnect_controller,
+        mock_disconnect_model,
+        mock_get_model,
+        mock_get_controller,
+    ):
+        mock_deploy.side_effect = Exception()
+        mock_get_model.return_value = juju.model.Model()
+        with self.assertRaises(Exception):
+            self.loop.run_until_complete(self.libjuju.deploy("cs:osm", "model"))
+        mock_deploy.assert_called_once()
+        mock_wait_for_model.assert_not_called()
+        mock_disconnect_controller.assert_called_once()
+        mock_disconnect_model.assert_called_once()
+
+
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller")
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.get_model")
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_model")
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller")
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.get_model")
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_model")
@@ -400,7 +559,12 @@ class DeployCharmTest(LibjujuTestCase):
         application = None
         with self.assertRaises(JujuApplicationExists):
             application = self.loop.run_until_complete(
         application = None
         with self.assertRaises(JujuApplicationExists):
             application = self.loop.run_until_complete(
-                self.libjuju.deploy_charm("existing_app", "path", "model", "machine",)
+                self.libjuju.deploy_charm(
+                    "existing_app",
+                    "path",
+                    "model",
+                    "machine",
+                )
             )
         self.assertIsNone(application)
 
             )
         self.assertIsNone(application)
 
@@ -424,7 +588,12 @@ class DeployCharmTest(LibjujuTestCase):
         application = None
         with self.assertRaises(JujuMachineNotFound):
             application = self.loop.run_until_complete(
         application = None
         with self.assertRaises(JujuMachineNotFound):
             application = self.loop.run_until_complete(
-                self.libjuju.deploy_charm("app", "path", "model", "machine",)
+                self.libjuju.deploy_charm(
+                    "app",
+                    "path",
+                    "model",
+                    "machine",
+                )
             )
 
         self.assertIsNone(application)
             )
 
         self.assertIsNone(application)
@@ -450,7 +619,11 @@ class DeployCharmTest(LibjujuTestCase):
         mock_deploy.return_value = FakeApplication()
         application = self.loop.run_until_complete(
             self.libjuju.deploy_charm(
         mock_deploy.return_value = FakeApplication()
         application = self.loop.run_until_complete(
             self.libjuju.deploy_charm(
-                "app", "path", "model", "existing_machine", num_units=2,
+                "app",
+                "path",
+                "model",
+                "existing_machine",
+                num_units=2,
             )
         )
 
             )
         )
 
@@ -500,7 +673,8 @@ class GetApplicationTest(LibjujuTestCase):
         super(GetApplicationTest, self).setUp()
 
     def test_existing_application(
         super(GetApplicationTest, self).setUp()
 
     def test_existing_application(
-        self, mock_applications,
+        self,
+        mock_applications,
     ):
         mock_applications.return_value = {"existing_app": "exists"}
         model = juju.model.Model()
     ):
         mock_applications.return_value = {"existing_app": "exists"}
         model = juju.model.Model()
@@ -508,7 +682,8 @@ class GetApplicationTest(LibjujuTestCase):
         self.assertEqual(result, "exists")
 
     def test_non_existing_application(
         self.assertEqual(result, "exists")
 
     def test_non_existing_application(
-        self, mock_applications,
+        self,
+        mock_applications,
     ):
         mock_applications.return_value = {"existing_app": "exists"}
         model = juju.model.Model()
     ):
         mock_applications.return_value = {"existing_app": "exists"}
         model = juju.model.Model()
@@ -545,7 +720,11 @@ class ExecuteActionTest(LibjujuTestCase):
         status = None
         with self.assertRaises(JujuApplicationNotFound):
             output, status = self.loop.run_until_complete(
         status = None
         with self.assertRaises(JujuApplicationNotFound):
             output, status = self.loop.run_until_complete(
-                self.libjuju.execute_action("app", "model", "action",)
+                self.libjuju.execute_action(
+                    "app",
+                    "model",
+                    "action",
+                )
             )
         self.assertIsNone(output)
         self.assertIsNone(status)
             )
         self.assertIsNone(output)
         self.assertIsNone(status)
@@ -571,7 +750,11 @@ class ExecuteActionTest(LibjujuTestCase):
         status = None
         with self.assertRaises(JujuActionNotFound):
             output, status = self.loop.run_until_complete(
         status = None
         with self.assertRaises(JujuActionNotFound):
             output, status = self.loop.run_until_complete(
-                self.libjuju.execute_action("app", "model", "action",)
+                self.libjuju.execute_action(
+                    "app",
+                    "model",
+                    "action",
+                )
             )
         self.assertIsNone(output)
         self.assertIsNone(status)
             )
         self.assertIsNone(output)
         self.assertIsNone(status)
@@ -579,7 +762,39 @@ class ExecuteActionTest(LibjujuTestCase):
         mock_disconnect_controller.assert_called()
         mock_disconnect_model.assert_called()
 
         mock_disconnect_controller.assert_called()
         mock_disconnect_model.assert_called()
 
-    # TODO no leader unit found exception
+    @asynctest.mock.patch("asyncio.sleep")
+    @asynctest.mock.patch("n2vc.tests.unit.utils.FakeUnit.is_leader_from_status")
+    def test_no_leader(
+        self,
+        mock_is_leader_from_status,
+        mock_sleep,
+        mock_get_action_status,
+        mock_get_action_output,
+        mock_wait_for,
+        mock__get_application,
+        mock_disconnect_controller,
+        mock_disconnect_model,
+        mock_get_model,
+        mock_get_controller,
+    ):
+        mock_get_model.return_value = juju.model.Model()
+        mock__get_application.return_value = FakeApplication()
+        mock_is_leader_from_status.return_value = False
+        output = None
+        status = None
+        with self.assertRaises(JujuLeaderUnitNotFound):
+            output, status = self.loop.run_until_complete(
+                self.libjuju.execute_action(
+                    "app",
+                    "model",
+                    "action",
+                )
+            )
+        self.assertIsNone(output)
+        self.assertIsNone(status)
+
+        mock_disconnect_controller.assert_called()
+        mock_disconnect_model.assert_called()
 
     def test_succesful_exec(
         self,
 
     def test_succesful_exec(
         self,
@@ -746,7 +961,11 @@ class AddRelationTest(LibjujuTestCase):
         mock_add_relation.side_effect = JujuAPIError(result)
 
         self.loop.run_until_complete(
         mock_add_relation.side_effect = JujuAPIError(result)
 
         self.loop.run_until_complete(
-            self.libjuju.add_relation("model", "app1:relation1", "app2:relation2",)
+            self.libjuju.add_relation(
+                "model",
+                "app1:relation1",
+                "app2:relation2",
+            )
         )
 
         mock_warning.assert_called_with("Relation not found: not found")
         )
 
         mock_warning.assert_called_with("Relation not found: not found")
@@ -770,7 +989,11 @@ class AddRelationTest(LibjujuTestCase):
         mock_add_relation.side_effect = JujuAPIError(result)
 
         self.loop.run_until_complete(
         mock_add_relation.side_effect = JujuAPIError(result)
 
         self.loop.run_until_complete(
-            self.libjuju.add_relation("model", "app1:relation1", "app2:relation2",)
+            self.libjuju.add_relation(
+                "model",
+                "app1:relation1",
+                "app2:relation2",
+            )
         )
 
         mock_warning.assert_called_with("Relation already exists: already exists")
         )
 
         mock_warning.assert_called_with("Relation already exists: already exists")
@@ -791,7 +1014,11 @@ class AddRelationTest(LibjujuTestCase):
 
         with self.assertRaises(JujuAPIError):
             self.loop.run_until_complete(
 
         with self.assertRaises(JujuAPIError):
             self.loop.run_until_complete(
-                self.libjuju.add_relation("model", "app1:relation1", "app2:relation2",)
+                self.libjuju.add_relation(
+                    "model",
+                    "app1:relation1",
+                    "app2:relation2",
+                )
             )
 
         mock_disconnect_controller.assert_called_once()
             )
 
         mock_disconnect_controller.assert_called_once()
@@ -808,7 +1035,11 @@ class AddRelationTest(LibjujuTestCase):
         mock_get_model.return_value = juju.model.Model()
 
         self.loop.run_until_complete(
         mock_get_model.return_value = juju.model.Model()
 
         self.loop.run_until_complete(
-            self.libjuju.add_relation("model", "app1:relation1", "app2:relation2",)
+            self.libjuju.add_relation(
+                "model",
+                "app1:relation1",
+                "app2:relation2",
+            )
         )
 
         mock_add_relation.assert_called_with("app1:relation1", "app2:relation2")
         )
 
         mock_add_relation.assert_called_with("app1:relation1", "app2:relation2")
@@ -826,7 +1057,11 @@ class AddRelationTest(LibjujuTestCase):
         mock_get_model.return_value = juju.model.Model()
 
         self.loop.run_until_complete(
         mock_get_model.return_value = juju.model.Model()
 
         self.loop.run_until_complete(
-            self.libjuju.add_relation("model", "app1:relation1", "saas_name",)
+            self.libjuju.add_relation(
+                "model",
+                "app1:relation1",
+                "saas_name",
+            )
         )
 
         mock_add_relation.assert_called_with("app1:relation1", "saas_name")
         )
 
         mock_add_relation.assert_called_with("app1:relation1", "saas_name")
@@ -837,37 +1072,37 @@ class AddRelationTest(LibjujuTestCase):
 # TODO destroy_model testcase
 
 
 # TODO destroy_model testcase
 
 
-@asynctest.mock.patch("juju.model.Model.get_machines")
-@asynctest.mock.patch("logging.Logger.debug")
-class DestroyMachineTest(LibjujuTestCase):
-    def setUp(self):
-        super(DestroyMachineTest, self).setUp()
-
-    def test_success(
-        self, mock_debug, mock_get_machines,
-    ):
-        mock_get_machines.side_effect = [
-            {"machine": FakeMachine()},
-            {"machine": FakeMachine()},
-            {},
-        ]
-        self.loop.run_until_complete(
-            self.libjuju.destroy_machine(juju.model.Model(), "machine", 2,)
-        )
-        calls = [
-            asynctest.call("Waiting for machine machine is destroyed"),
-            asynctest.call("Machine destroyed: machine"),
-        ]
-        mock_debug.assert_has_calls(calls)
-
-    def test_no_machine(
-        self, mock_debug, mock_get_machines,
-    ):
-        mock_get_machines.return_value = {}
-        self.loop.run_until_complete(
-            self.libjuju.destroy_machine(juju.model.Model(), "machine", 2,)
-        )
-        mock_debug.assert_called_with("Machine not found: machine")
+# @asynctest.mock.patch("juju.model.Model.get_machines")
+# @asynctest.mock.patch("logging.Logger.debug")
+# class DestroyMachineTest(LibjujuTestCase):
+#     def setUp(self):
+#         super(DestroyMachineTest, self).setUp()
+
+#     def test_success_manual_machine(
+#         self, mock_debug, mock_get_machines,
+#     ):
+#         mock_get_machines.side_effect = [
+#             {"machine": FakeManualMachine()},
+#             {"machine": FakeManualMachine()},
+#             {},
+#         ]
+#         self.loop.run_until_complete(
+#             self.libjuju.destroy_machine(juju.model.Model(), "machine", 2,)
+#         )
+#         calls = [
+#             asynctest.call("Waiting for machine machine is destroyed"),
+#             asynctest.call("Machine destroyed: machine"),
+#         ]
+#         mock_debug.assert_has_calls(calls)
+
+#     def test_no_machine(
+#         self, mock_debug, mock_get_machines,
+#     ):
+#         mock_get_machines.return_value = {}
+#         self.loop.run_until_complete(
+#             self.libjuju.destroy_machine(juju.model.Model(), "machine", 2)
+#         )
+#         mock_debug.assert_called_with("Machine not found: machine")
 
 
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller")
 
 
 @asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller")
@@ -891,7 +1126,11 @@ class ConfigureApplicationTest(LibjujuTestCase):
         mock_get_application.return_value = FakeApplication()
 
         self.loop.run_until_complete(
         mock_get_application.return_value = FakeApplication()
 
         self.loop.run_until_complete(
-            self.libjuju.configure_application("model", "app", {"config"},)
+            self.libjuju.configure_application(
+                "model",
+                "app",
+                {"config"},
+            )
         )
         mock_get_application.assert_called_once()
         mock_disconnect_controller.assert_called_once()
         )
         mock_get_application.assert_called_once()
         mock_disconnect_controller.assert_called_once()
@@ -910,11 +1149,64 @@ class ConfigureApplicationTest(LibjujuTestCase):
 
         with self.assertRaises(Exception):
             self.loop.run_until_complete(
 
         with self.assertRaises(Exception):
             self.loop.run_until_complete(
-                self.libjuju.configure_application("model", "app", {"config"},)
+                self.libjuju.configure_application(
+                    "model",
+                    "app",
+                    {"config"},
+                )
             )
         mock_disconnect_controller.assert_called_once()
         mock_disconnect_model.assert_called_once()
 
             )
         mock_disconnect_controller.assert_called_once()
         mock_disconnect_model.assert_called_once()
 
+    def test_controller_exception(
+        self,
+        mock_get_application,
+        mock_disconnect_controller,
+        mock_disconnect_model,
+        mock_get_model,
+        mock_get_controller,
+    ):
+
+        result = {"error": "not found", "response": "response", "request-id": 1}
+
+        mock_get_controller.side_effect = JujuAPIError(result)
+
+        with self.assertRaises(JujuAPIError):
+            self.loop.run_until_complete(
+                self.libjuju.configure_application(
+                    "model",
+                    "app",
+                    {"config"},
+                )
+            )
+        mock_get_model.assert_not_called()
+        mock_disconnect_controller.assert_not_called()
+        mock_disconnect_model.assert_not_called()
+
+    def test_get_model_exception(
+        self,
+        mock_get_application,
+        mock_disconnect_controller,
+        mock_disconnect_model,
+        mock_get_model,
+        mock_get_controller,
+    ):
+
+        result = {"error": "not found", "response": "response", "request-id": 1}
+        mock_get_model.side_effect = JujuAPIError(result)
+
+        with self.assertRaises(JujuAPIError):
+            self.loop.run_until_complete(
+                self.libjuju.configure_application(
+                    "model",
+                    "app",
+                    {"config"},
+                )
+            )
+        mock_get_model.assert_called_once()
+        mock_disconnect_controller.assert_called_once()
+        mock_disconnect_model.assert_not_called()
+
 
 # TODO _get_api_endpoints_db test case
 # TODO _update_api_endpoints_db test case
 
 # TODO _get_api_endpoints_db test case
 # TODO _update_api_endpoints_db test case
@@ -929,7 +1221,10 @@ class ListModelsTest(LibjujuTestCase):
         super(ListModelsTest, self).setUp()
 
     def test_containing(
         super(ListModelsTest, self).setUp()
 
     def test_containing(
-        self, mock_list_models, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_list_models,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_models.return_value = ["existingmodel"]
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_models.return_value = ["existingmodel"]
@@ -939,7 +1234,10 @@ class ListModelsTest(LibjujuTestCase):
         self.assertEquals(models, ["existingmodel"])
 
     def test_not_containing(
         self.assertEquals(models, ["existingmodel"])
 
     def test_not_containing(
-        self, mock_list_models, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_list_models,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_models.return_value = ["existingmodel", "model"]
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_models.return_value = ["existingmodel", "model"]
@@ -949,7 +1247,10 @@ class ListModelsTest(LibjujuTestCase):
         self.assertEquals(models, [])
 
     def test_no_contains_arg(
         self.assertEquals(models, [])
 
     def test_no_contains_arg(
-        self, mock_list_models, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_list_models,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_models.return_value = ["existingmodel", "model"]
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_models.return_value = ["existingmodel", "model"]
@@ -1001,7 +1302,10 @@ class ListOffers(LibjujuTestCase):
         super(ListOffers, self).setUp()
 
     def test_disconnect_controller(
         super(ListOffers, self).setUp()
 
     def test_disconnect_controller(
-        self, mock_list_offers, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_list_offers,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_offers.side_effect = Exception()
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_offers.side_effect = Exception()
@@ -1010,7 +1314,10 @@ class ListOffers(LibjujuTestCase):
         mock_disconnect_controller.assert_called_once()
 
     def test_empty_list(
         mock_disconnect_controller.assert_called_once()
 
     def test_empty_list(
-        self, mock_list_offers, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_list_offers,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_offers.return_value = []
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_offers.return_value = []
@@ -1019,7 +1326,10 @@ class ListOffers(LibjujuTestCase):
         mock_disconnect_controller.assert_called_once()
 
     def test_non_empty_list(
         mock_disconnect_controller.assert_called_once()
 
     def test_non_empty_list(
-        self, mock_list_offers, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_list_offers,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_offers.return_value = ["offer"]
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_list_offers.return_value = ["offer"]
@@ -1256,7 +1566,10 @@ class RemoveCloudTest(LibjujuTestCase):
         super(RemoveCloudTest, self).setUp()
 
     def test_remove_cloud(
         super(RemoveCloudTest, self).setUp()
 
     def test_remove_cloud(
-        self, mock_remove_cloud, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_remove_cloud,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
 
     ):
         mock_get_controller.return_value = juju.controller.Controller()
 
@@ -1265,7 +1578,10 @@ class RemoveCloudTest(LibjujuTestCase):
         mock_disconnect_controller.assert_called_once()
 
     def test_remove_cloud_exception(
         mock_disconnect_controller.assert_called_once()
 
     def test_remove_cloud_exception(
-        self, mock_remove_cloud, mock_disconnect_controller, mock_get_controller,
+        self,
+        mock_remove_cloud,
+        mock_disconnect_controller,
+        mock_get_controller,
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_remove_cloud.side_effect = Exception()
     ):
         mock_get_controller.return_value = juju.controller.Controller()
         mock_remove_cloud.side_effect = Exception()
@@ -1294,7 +1610,8 @@ class GetK8sCloudCredentials(LibjujuTestCase):
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
-                e.message, "authentication method not supported",
+                e.message,
+                "authentication method not supported",
             )
         self.assertTrue(exception_raised)
 
             )
         self.assertTrue(exception_raised)
 
@@ -1385,7 +1702,8 @@ class GetK8sCloudCredentials(LibjujuTestCase):
         self.assertEqual(
             credential,
             juju.client._definitions.CloudCredential(
         self.assertEqual(
             credential,
             juju.client._definitions.CloudCredential(
-                attrs={"ClientKeyData": "key", "Token": "Token"}, auth_type="oauth2",
+                attrs={"ClientKeyData": "key", "Token": "Token"},
+                auth_type="oauth2",
             ),
         )
 
             ),
         )
 
@@ -1405,7 +1723,8 @@ class GetK8sCloudCredentials(LibjujuTestCase):
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
-                e.message, "missing token for auth type oauth2",
+                e.message,
+                "missing token for auth type oauth2",
             )
         self.assertTrue(exception_raised)
 
             )
         self.assertTrue(exception_raised)
 
@@ -1422,7 +1741,8 @@ class GetK8sCloudCredentials(LibjujuTestCase):
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
-                e.message, "unknown format of api_key",
+                e.message,
+                "unknown format of api_key",
             )
         self.assertTrue(exception_raised)
 
             )
         self.assertTrue(exception_raised)
 
@@ -1439,6 +1759,7 @@ class GetK8sCloudCredentials(LibjujuTestCase):
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
         except JujuInvalidK8sConfiguration as e:
             exception_raised = True
             self.assertEqual(
-                e.message, "Cannot set both token and user/pass",
+                e.message,
+                "Cannot set both token and user/pass",
             )
         self.assertTrue(exception_raised)
             )
         self.assertTrue(exception_raised)