X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FN2VC.git;a=blobdiff_plain;f=n2vc%2Ftests%2Funit%2Ftest_libjuju.py;h=724b5d7a491152beb6adda5be213166e8c966219;hp=76bbebe895d2cc9bc4adcf6e2b3cf156a8b3a68d;hb=4ae527ee394a9794c25e7a90fe895aa446c6c797;hpb=a4f57d6260e6520aa6a89e86f9d1b2ca5e0a3a08 diff --git a/n2vc/tests/unit/test_libjuju.py b/n2vc/tests/unit/test_libjuju.py index 76bbebe..724b5d7 100644 --- a/n2vc/tests/unit/test_libjuju.py +++ b/n2vc/tests/unit/test_libjuju.py @@ -15,147 +15,64 @@ import asyncio import asynctest import tempfile -from unittest import mock +from unittest.mock import Mock, patch import juju import kubernetes from juju.errors import JujuAPIError import logging -from .utils import FakeN2VC, FakeMachine, FakeApplication +from .utils import FakeMachine, FakeApplication from n2vc.libjuju import Libjuju from n2vc.exceptions import ( JujuControllerFailedConnecting, - JujuModelAlreadyExists, JujuMachineNotFound, JujuApplicationNotFound, JujuActionNotFound, JujuApplicationExists, JujuInvalidK8sConfiguration, JujuLeaderUnitNotFound, + JujuError, ) +from n2vc.k8s_juju_conn import generate_rbac_id +from n2vc.tests.unit.utils import AsyncMock +from n2vc.vca.connection import Connection +from n2vc.vca.connection_data import ConnectionData +cacert = """-----BEGIN CERTIFICATE----- +SOMECERT +-----END CERTIFICATE-----""" + + +@asynctest.mock.patch("n2vc.libjuju.Controller") class LibjujuTestCase(asynctest.TestCase): - @asynctest.mock.patch("juju.controller.Controller.update_endpoints") - @asynctest.mock.patch("juju.client.connector.Connector.connect") - @asynctest.mock.patch("juju.controller.Controller.connection") - @asynctest.mock.patch("n2vc.libjuju.Libjuju._get_api_endpoints_db") + @asynctest.mock.patch("n2vc.vca.connection_data.base64_to_cacert") def setUp( self, - mock__get_api_endpoints_db=None, - mock_connection=None, - mock_connect=None, - mock_update_endpoints=None, - ): - loop = asyncio.get_event_loop() - n2vc = FakeN2VC() - mock__get_api_endpoints_db.return_value = ["127.0.0.1:17070"] - endpoints = "127.0.0.1:17070" - username = "admin" - password = "secret" - cacert = """ - -----BEGIN CERTIFICATE----- - SOMECERT - -----END CERTIFICATE-----""" - self.libjuju = Libjuju( - endpoints, - "192.168.0.155:17070", - username, - password, - cacert, - loop, - log=None, - db={"get_one": []}, - n2vc=n2vc, - apt_mirror="192.168.0.100", - enable_os_upgrade=True, - ) - logging.disable(logging.CRITICAL) - 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): + mock_base64_to_cacert=None, + ): 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, + self.db = Mock() + mock_base64_to_cacert.return_value = cacert + Connection._load_vca_connection_data = Mock() + vca_connection = Connection(AsyncMock()) + vca_connection._data = ConnectionData( + **{ + "endpoints": ["1.2.3.4:17070"], + "user": "user", + "secret": "secret", + "cacert": "cacert", + "pubkey": "pubkey", + "lxd-cloud": "cloud", + "lxd-credentials": "credentials", + "k8s-cloud": "k8s_cloud", + "k8s-credentials": "k8s_credentials", + "model-config": {}, + "api-proxy": "api_proxy", + } ) - 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() + logging.disable(logging.CRITICAL) + self.libjuju = Libjuju(vca_connection, self.loop) + self.loop.run_until_complete(self.libjuju.disconnect()) @asynctest.mock.patch("juju.controller.Controller.connect") @@ -163,41 +80,34 @@ class LibjujuInitTestCase(asynctest.TestCase): "juju.controller.Controller.api_endpoints", new_callable=asynctest.CoroutineMock(return_value=["127.0.0.1:17070"]), ) -@asynctest.mock.patch("n2vc.libjuju.Libjuju._update_api_endpoints_db") class GetControllerTest(LibjujuTestCase): def setUp(self): super(GetControllerTest, self).setUp() - def test_diff_endpoint( - self, mock__update_api_endpoints_db, mock_api_endpoints, mock_connect - ): + def test_diff_endpoint(self, mock_api_endpoints, mock_connect): self.libjuju.endpoints = [] controller = self.loop.run_until_complete(self.libjuju.get_controller()) - mock__update_api_endpoints_db.assert_called_once_with(["127.0.0.1:17070"]) self.assertIsInstance(controller, juju.controller.Controller) @asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_controller") def test_exception( self, mock_disconnect_controller, - mock__update_api_endpoints_db, mock_api_endpoints, mock_connect, ): self.libjuju.endpoints = [] - mock__update_api_endpoints_db.side_effect = Exception() + + mock_connect.side_effect = Exception() controller = None with self.assertRaises(JujuControllerFailedConnecting): controller = self.loop.run_until_complete(self.libjuju.get_controller()) self.assertIsNone(controller) - mock_disconnect_controller.assert_called_once() + mock_disconnect_controller.assert_called() - def test_same_endpoint_get_controller( - self, mock__update_api_endpoints_db, mock_api_endpoints, mock_connect - ): + def test_same_endpoint_get_controller(self, mock_api_endpoints, mock_connect): self.libjuju.endpoints = ["127.0.0.1:17070"] controller = self.loop.run_until_complete(self.libjuju.get_controller()) - mock__update_api_endpoints_db.assert_not_called() self.assertIsInstance(controller, juju.controller.Controller) @@ -237,10 +147,8 @@ class AddModelTest(LibjujuTestCase): ): mock_model_exists.return_value = True - with self.assertRaises(JujuModelAlreadyExists): - self.loop.run_until_complete( - self.libjuju.add_model("existing_model", "cloud") - ) + # This should not raise an exception + self.loop.run_until_complete(self.libjuju.add_model("existing_model", "cloud")) mock_disconnect_controller.assert_called() @@ -258,7 +166,7 @@ class AddModelTest(LibjujuTestCase): mock_get_controller.return_value = juju.controller.Controller() self.loop.run_until_complete( - self.libjuju.add_model("nonexisting_model", "cloud") + self.libjuju.add_model("nonexisting_model", Mock()) ) mock_add_model.assert_called_once() @@ -266,13 +174,134 @@ class AddModelTest(LibjujuTestCase): mock_disconnect_model.assert_called() +@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( + "juju.model.Model.applications", new_callable=asynctest.PropertyMock +) +@asynctest.mock.patch("juju.model.Model.get_action_status") +@asynctest.mock.patch("juju.model.Model.get_action_output") +@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_actions") +class GetExecutedActionsTest(LibjujuTestCase): + def setUp(self): + super(GetExecutedActionsTest, self).setUp() + + def test_exception( + self, + mock_get_actions, + mock_get_action_output, + mock_get_action_status, + mock_applications, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_model, + mock_get_controller, + ): + mock_get_model.return_value = None + with self.assertRaises(JujuError): + self.loop.run_until_complete(self.libjuju.get_executed_actions("model")) + + mock_get_controller.assert_called_once() + mock_disconnect_controller.assert_called_once() + mock_get_model.assert_called_once() + mock_disconnect_model.assert_not_called() + + def test_success( + self, + mock_get_actions, + mock_get_action_output, + mock_get_action_status, + mock_applications, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_model, + mock_get_controller, + ): + mock_get_model.return_value = juju.model.Model() + mock_applications.return_value = {"existing_app"} + mock_get_actions.return_value = {"action_name": "description"} + mock_get_action_status.return_value = {"id": "status"} + mock_get_action_output.return_value = {"output": "completed"} + + executed_actions = self.loop.run_until_complete( + self.libjuju.get_executed_actions("model") + ) + expected_result = [ + { + "id": "id", + "action": "action_name", + "status": "status", + "output": "completed", + } + ] + self.assertListEqual(expected_result, executed_actions) + self.assertIsInstance(executed_actions, list) + + mock_get_controller.assert_called_once() + mock_get_model.assert_called_once() + 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.disconnect_controller") +@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_application") +class GetApplicationConfigsTest(LibjujuTestCase): + def setUp(self): + super(GetApplicationConfigsTest, self).setUp() + + def test_exception( + self, + mock_get_application, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_model, + mock_get_controller, + ): + mock_get_model.return_value = None + with self.assertRaises(JujuError): + self.loop.run_until_complete( + self.libjuju.get_application_configs("model", "app") + ) + + mock_get_controller.assert_called_once() + mock_disconnect_controller.assert_called_once() + mock_get_model.assert_called_once() + mock_disconnect_model.assert_not_called() + + def test_success( + self, + mock_get_application, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_model, + mock_get_controller, + ): + mock_get_application.return_value = FakeApplication() + application_configs = self.loop.run_until_complete( + self.libjuju.get_application_configs("model", "app") + ) + + self.assertEqual(application_configs, ["app_config"]) + + mock_get_controller.assert_called_once() + mock_get_model.assert_called_once() + mock_disconnect_controller.assert_called_once() + mock_disconnect_model.assert_called_once() + + @asynctest.mock.patch("juju.controller.Controller.get_model") class GetModelTest(LibjujuTestCase): def setUp(self): 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( @@ -288,7 +317,9 @@ class ModelExistsTest(LibjujuTestCase): 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( @@ -299,7 +330,10 @@ class ModelExistsTest(LibjujuTestCase): @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() @@ -307,7 +341,9 @@ class ModelExistsTest(LibjujuTestCase): 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( @@ -453,6 +489,71 @@ class CreateMachineTest(LibjujuTestCase): # 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") @@ -486,7 +587,12 @@ class DeployCharmTest(LibjujuTestCase): 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) @@ -510,7 +616,12 @@ class DeployCharmTest(LibjujuTestCase): 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) @@ -536,7 +647,11 @@ class DeployCharmTest(LibjujuTestCase): 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, ) ) @@ -586,7 +701,8 @@ class GetApplicationTest(LibjujuTestCase): 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() @@ -594,7 +710,8 @@ class GetApplicationTest(LibjujuTestCase): 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() @@ -631,7 +748,11 @@ class ExecuteActionTest(LibjujuTestCase): 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) @@ -657,7 +778,11 @@ class ExecuteActionTest(LibjujuTestCase): 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) @@ -687,7 +812,11 @@ class ExecuteActionTest(LibjujuTestCase): status = None with self.assertRaises(JujuLeaderUnitNotFound): 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) @@ -860,7 +989,11 @@ class AddRelationTest(LibjujuTestCase): 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") @@ -884,7 +1017,11 @@ class AddRelationTest(LibjujuTestCase): 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") @@ -905,7 +1042,11 @@ class AddRelationTest(LibjujuTestCase): 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() @@ -922,7 +1063,11 @@ class AddRelationTest(LibjujuTestCase): 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") @@ -940,7 +1085,11 @@ class AddRelationTest(LibjujuTestCase): 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") @@ -951,6 +1100,78 @@ class AddRelationTest(LibjujuTestCase): # TODO destroy_model testcase +@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller") +@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_model") +@asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_controller") +@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_application") +@asynctest.mock.patch("n2vc.libjuju.Libjuju.disconnect_model") +class DestroyApplicationTest(LibjujuTestCase): + def setUp(self): + super(DestroyApplicationTest, self).setUp() + + def test_success( + self, + mock_get_controller, + mock_get_model, + mock_disconnect_controller, + mock_get_application, + mock_disconnect_model, + ): + mock_get_application.return_value = FakeApplication() + mock_get_model.return_value = None + self.loop.run_until_complete( + self.libjuju.destroy_application( + "existing_model", + "existing_app", + 3600, + ) + ) + mock_get_application.assert_called() + mock_disconnect_controller.assert_called_once() + mock_disconnect_model.assert_called_once() + + def test_no_application( + self, + mock_get_controller, + mock_get_model, + mock_disconnect_controller, + mock_get_application, + mock_disconnect_model, + ): + mock_get_model.return_value = None + mock_get_application.return_value = None + + self.loop.run_until_complete( + self.libjuju.destroy_application( + "existing_model", + "existing_app", + 3600, + ) + ) + mock_get_application.assert_called() + + def test_exception( + self, + mock_get_controller, + mock_get_model, + mock_disconnect_controller, + mock_get_application, + mock_disconnect_model, + ): + mock_get_application.return_value = FakeApplication + mock_get_model.return_value = None + + with self.assertRaises(Exception): + self.loop.run_until_complete( + self.libjuju.destroy_application( + "existing_model", + "existing_app", + 0, + ) + ) + mock_get_application.assert_called_once() + + # @asynctest.mock.patch("juju.model.Model.get_machines") # @asynctest.mock.patch("logging.Logger.debug") # class DestroyMachineTest(LibjujuTestCase): @@ -1005,7 +1226,11 @@ class ConfigureApplicationTest(LibjujuTestCase): 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() @@ -1024,11 +1249,64 @@ class ConfigureApplicationTest(LibjujuTestCase): 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() + 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 @@ -1043,7 +1321,10 @@ class ListModelsTest(LibjujuTestCase): 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"] @@ -1053,7 +1334,10 @@ class ListModelsTest(LibjujuTestCase): 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"] @@ -1063,7 +1347,10 @@ class ListModelsTest(LibjujuTestCase): 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"] @@ -1115,7 +1402,10 @@ class ListOffers(LibjujuTestCase): 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() @@ -1124,7 +1414,10 @@ class ListOffers(LibjujuTestCase): 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 = [] @@ -1133,7 +1426,10 @@ class ListOffers(LibjujuTestCase): 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"] @@ -1235,45 +1531,56 @@ class ConsumeTest(LibjujuTestCase): class AddK8sTest(LibjujuTestCase): def setUp(self): super(AddK8sTest, self).setUp() - self.configuration = kubernetes.client.configuration.Configuration() + name = "cloud" + rbac_id = generate_rbac_id() + token = "token" + client_cert_data = "cert" + configuration = kubernetes.client.configuration.Configuration() + storage_class = "storage_class" + credential_name = name + + self._add_k8s_args = { + "name": name, + "rbac_id": rbac_id, + "token": token, + "client_cert_data": client_cert_data, + "configuration": configuration, + "storage_class": storage_class, + "credential_name": credential_name, + } def test_add_k8s(self, mock_add_cloud, mock_get_k8s_cloud_credential): - self.loop.run_until_complete( - self.libjuju.add_k8s("cloud", self.configuration, "storage_class") - ) + self.loop.run_until_complete(self.libjuju.add_k8s(**self._add_k8s_args)) mock_add_cloud.assert_called_once() mock_get_k8s_cloud_credential.assert_called_once() def test_add_k8s_exception(self, mock_add_cloud, mock_get_k8s_cloud_credential): mock_add_cloud.side_effect = Exception() with self.assertRaises(Exception): - self.loop.run_until_complete( - self.libjuju.add_k8s("cloud", self.configuration, "storage_class") - ) + self.loop.run_until_complete(self.libjuju.add_k8s(**self._add_k8s_args)) mock_add_cloud.assert_called_once() mock_get_k8s_cloud_credential.assert_called_once() def test_add_k8s_missing_name(self, mock_add_cloud, mock_get_k8s_cloud_credential): + self._add_k8s_args["name"] = "" with self.assertRaises(Exception): - self.loop.run_until_complete( - self.libjuju.add_k8s("", self.configuration, "storage_class") - ) + self.loop.run_until_complete(self.libjuju.add_k8s(**self._add_k8s_args)) mock_add_cloud.assert_not_called() def test_add_k8s_missing_storage_name( self, mock_add_cloud, mock_get_k8s_cloud_credential ): + self._add_k8s_args["storage_class"] = "" with self.assertRaises(Exception): - self.loop.run_until_complete( - self.libjuju.add_k8s("cloud", self.configuration, "") - ) + self.loop.run_until_complete(self.libjuju.add_k8s(**self._add_k8s_args)) mock_add_cloud.assert_not_called() def test_add_k8s_missing_configuration_keys( self, mock_add_cloud, mock_get_k8s_cloud_credential ): + self._add_k8s_args["configuration"] = None with self.assertRaises(Exception): - self.loop.run_until_complete(self.libjuju.add_k8s("cloud", None, "")) + self.loop.run_until_complete(self.libjuju.add_k8s(**self._add_k8s_args)) mock_add_cloud.assert_not_called() @@ -1370,7 +1677,10 @@ class RemoveCloudTest(LibjujuTestCase): 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() @@ -1379,7 +1689,10 @@ class RemoveCloudTest(LibjujuTestCase): 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() @@ -1394,6 +1707,8 @@ class RemoveCloudTest(LibjujuTestCase): class GetK8sCloudCredentials(LibjujuTestCase): def setUp(self): super(GetK8sCloudCredentials, self).setUp() + self.cert_data = "cert" + self.token = "token" @asynctest.mock.patch("n2vc.exceptions.JujuInvalidK8sConfiguration") def test_not_supported(self, mock_exception, mock_configuration): @@ -1403,12 +1718,19 @@ class GetK8sCloudCredentials(LibjujuTestCase): mock_configuration.cert_file = None mock_configuration.key_file = None exception_raised = False + self.token = None + self.cert_data = None try: - _ = self.libjuju.get_k8s_cloud_credential(mock_configuration) + _ = self.libjuju.get_k8s_cloud_credential( + mock_configuration, + self.cert_data, + self.token, + ) 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) @@ -1418,7 +1740,13 @@ class GetK8sCloudCredentials(LibjujuTestCase): mock_configuration.ssl_ca_cert = None mock_configuration.cert_file = None mock_configuration.key_file = None - credential = self.libjuju.get_k8s_cloud_credential(mock_configuration) + self.token = None + self.cert_data = None + credential = self.libjuju.get_k8s_cloud_credential( + mock_configuration, + self.cert_data, + self.token, + ) self.assertEqual( credential, juju.client._definitions.CloudCredential( @@ -1426,46 +1754,54 @@ class GetK8sCloudCredentials(LibjujuTestCase): ), ) - def test_user_no_pass(self, mock_configuration): - mock_configuration.username = "admin" - mock_configuration.password = "" - mock_configuration.ssl_ca_cert = None - mock_configuration.cert_file = None - mock_configuration.key_file = None - with mock.patch.object(self.libjuju.log, "debug") as mock_debug: - credential = self.libjuju.get_k8s_cloud_credential(mock_configuration) - self.assertEqual( - credential, - juju.client._definitions.CloudCredential( - attrs={"username": "admin", "password": ""}, auth_type="userpass" - ), - ) - mock_debug.assert_called_once_with( - "credential for user admin has empty password" - ) - def test_user_pass_with_cert(self, mock_configuration): mock_configuration.username = "admin" mock_configuration.password = "admin" - ssl_ca_cert = tempfile.NamedTemporaryFile() - with open(ssl_ca_cert.name, "w") as ssl_ca_cert_file: - ssl_ca_cert_file.write("cacert") - mock_configuration.ssl_ca_cert = ssl_ca_cert.name + mock_configuration.ssl_ca_cert = None mock_configuration.cert_file = None mock_configuration.key_file = None - credential = self.libjuju.get_k8s_cloud_credential(mock_configuration) + self.token = None + credential = self.libjuju.get_k8s_cloud_credential( + mock_configuration, + self.cert_data, + self.token, + ) self.assertEqual( credential, juju.client._definitions.CloudCredential( attrs={ + "ClientCertificateData": self.cert_data, "username": "admin", "password": "admin", - "ClientCertificateData": "cacert", }, auth_type="userpasswithcert", ), ) + def test_user_no_pass(self, mock_configuration): + mock_configuration.username = "admin" + mock_configuration.password = "" + mock_configuration.ssl_ca_cert = None + mock_configuration.cert_file = None + mock_configuration.key_file = None + self.token = None + self.cert_data = None + with patch.object(self.libjuju.log, "debug") as mock_debug: + credential = self.libjuju.get_k8s_cloud_credential( + mock_configuration, + self.cert_data, + self.token, + ) + self.assertEqual( + credential, + juju.client._definitions.CloudCredential( + attrs={"username": "admin", "password": ""}, auth_type="userpass" + ), + ) + mock_debug.assert_called_once_with( + "credential for user admin has empty password" + ) + def test_cert(self, mock_configuration): mock_configuration.username = "" mock_configuration.password = "" @@ -1476,69 +1812,67 @@ class GetK8sCloudCredentials(LibjujuTestCase): mock_configuration.ssl_ca_cert = ssl_ca_cert.name mock_configuration.cert_file = None mock_configuration.key_file = None - credential = self.libjuju.get_k8s_cloud_credential(mock_configuration) + credential = self.libjuju.get_k8s_cloud_credential( + mock_configuration, + self.cert_data, + self.token, + ) self.assertEqual( credential, juju.client._definitions.CloudCredential( - attrs={"ClientCertificateData": "cacert", "Token": "Token"}, + attrs={"ClientCertificateData": self.cert_data, "Token": self.token}, auth_type="certificate", ), ) - def test_oauth2(self, mock_configuration): - mock_configuration.username = "" - mock_configuration.password = "" - mock_configuration.api_key = {"authorization": "Bearer Token"} - key = tempfile.NamedTemporaryFile() - with open(key.name, "w") as key_file: - key_file.write("key") - mock_configuration.ssl_ca_cert = None - mock_configuration.cert_file = None - mock_configuration.key_file = key.name - credential = self.libjuju.get_k8s_cloud_credential(mock_configuration) - self.assertEqual( - credential, - juju.client._definitions.CloudCredential( - attrs={"ClientKeyData": "key", "Token": "Token"}, auth_type="oauth2", - ), - ) - - @asynctest.mock.patch("n2vc.exceptions.JujuInvalidK8sConfiguration") - def test_oauth2_missing_token(self, mock_exception, mock_configuration): - mock_configuration.username = "" - mock_configuration.password = "" - key = tempfile.NamedTemporaryFile() - with open(key.name, "w") as key_file: - key_file.write("key") - mock_configuration.ssl_ca_cert = None - mock_configuration.cert_file = None - mock_configuration.key_file = key.name - exception_raised = False - try: - _ = self.libjuju.get_k8s_cloud_credential(mock_configuration) - except JujuInvalidK8sConfiguration as e: - exception_raised = True - self.assertEqual( - e.message, "missing token for auth type oauth2", - ) - self.assertTrue(exception_raised) - - def test_unknown_api_key(self, mock_configuration): - mock_configuration.username = "" - mock_configuration.password = "" - mock_configuration.api_key = {"authorization": "Bearer Token Wrong"} - mock_configuration.ssl_ca_cert = None - mock_configuration.cert_file = None - mock_configuration.key_file = None - exception_raised = False - try: - _ = self.libjuju.get_k8s_cloud_credential(mock_configuration) - except JujuInvalidK8sConfiguration as e: - exception_raised = True - self.assertEqual( - e.message, "unknown format of api_key", - ) - self.assertTrue(exception_raised) + # TODO: Fix this test when oauth authentication is supported + # def test_oauth2(self, mock_configuration): + # mock_configuration.username = "" + # mock_configuration.password = "" + # mock_configuration.api_key = {"authorization": "Bearer Token"} + # key = tempfile.NamedTemporaryFile() + # with open(key.name, "w") as key_file: + # key_file.write("key") + # mock_configuration.ssl_ca_cert = None + # mock_configuration.cert_file = None + # mock_configuration.key_file = key.name + # credential = self.libjuju.get_k8s_cloud_credential( + # mock_configuration, + # self.cert_data, + # self.token, + # ) + # self.assertEqual( + # credential, + # juju.client._definitions.CloudCredential( + # attrs={"ClientKeyData": "key", "Token": "Token"}, + # auth_type="oauth2", + # ), + # ) + + # @asynctest.mock.patch("n2vc.exceptions.JujuInvalidK8sConfiguration") + # def test_oauth2_missing_token(self, mock_exception, mock_configuration): + # mock_configuration.username = "" + # mock_configuration.password = "" + # key = tempfile.NamedTemporaryFile() + # with open(key.name, "w") as key_file: + # key_file.write("key") + # mock_configuration.ssl_ca_cert = None + # mock_configuration.cert_file = None + # mock_configuration.key_file = key.name + # exception_raised = False + # try: + # _ = self.libjuju.get_k8s_cloud_credential( + # mock_configuration, + # self.cert_data, + # self.token, + # ) + # except JujuInvalidK8sConfiguration as e: + # exception_raised = True + # self.assertEqual( + # e.message, + # "missing token for auth type oauth2", + # ) + # self.assertTrue(exception_raised) def test_exception_cannot_set_token_and_userpass(self, mock_configuration): mock_configuration.username = "admin" @@ -1549,10 +1883,103 @@ class GetK8sCloudCredentials(LibjujuTestCase): mock_configuration.key_file = None exception_raised = False try: - _ = self.libjuju.get_k8s_cloud_credential(mock_configuration) + _ = self.libjuju.get_k8s_cloud_credential( + mock_configuration, + self.cert_data, + self.token, + ) 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) + + +@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_controller") +@asynctest.mock.patch("n2vc.libjuju.Libjuju.get_model") +@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_application") +@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") +class ScaleApplicationTest(LibjujuTestCase): + def setUp(self): + super(ScaleApplicationTest, self).setUp() + + @asynctest.mock.patch("asyncio.sleep") + def test_scale_application( + self, + mock_sleep, + mock_wait_for_model, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_application, + mock_get_model, + mock_get_controller, + ): + mock_get_model.return_value = juju.model.Model() + mock_get_application.return_value = FakeApplication() + self.loop.run_until_complete(self.libjuju.scale_application("model", "app", 2)) + mock_wait_for_model.assert_called_once() + mock_disconnect_controller.assert_called_once() + mock_disconnect_model.assert_called_once() + + def test_no_application( + self, + mock_wait_for, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_application, + mock_get_model, + mock_get_controller, + ): + mock_get_application.return_value = None + mock_get_model.return_value = juju.model.Model() + with self.assertRaises(JujuApplicationNotFound): + self.loop.run_until_complete( + self.libjuju.scale_application("model", "app", 2) + ) + mock_disconnect_controller.assert_called() + mock_disconnect_model.assert_called() + + def test_exception( + self, + mock_wait_for, + mock_disconnect_controller, + mock_disconnect_model, + mock_get_application, + mock_get_model, + mock_get_controller, + ): + mock_get_model.return_value = None + mock_get_application.return_value = FakeApplication() + with self.assertRaises(Exception): + self.loop.run_until_complete( + self.libjuju.scale_application("model", "app", 2, total_timeout=0) + ) + mock_disconnect_controller.assert_called_once() + + +@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_application") +class GetUnitNumberTest(LibjujuTestCase): + def setUp(self): + super(GetUnitNumberTest, self).setUp() + + def test_succesful_get_unit_number( + self, + mock_get_applications, + ): + mock_get_applications.return_value = FakeApplication() + model = juju.model.Model() + result = self.libjuju._get_application_count(model, "app") + self.assertEqual(result, 2) + + def test_non_existing_application( + self, + mock_get_applications, + ): + mock_get_applications.return_value = None + model = juju.model.Model() + result = self.libjuju._get_application_count(model, "app") + self.assertEqual(result, None)