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 (
+ FakeApplication,
+ FakeMachine,
+ FakeManualMachine,
+ FakeUnit,
+)
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,
+ mock_base64_to_cacert=None,
+ ):
+ self.loop = asyncio.get_event_loop()
+ 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",
+ }
)
logging.disable(logging.CRITICAL)
- loop.run_until_complete(self.libjuju.disconnect())
+ self.libjuju = Libjuju(vca_connection, self.loop)
+ self.loop.run_until_complete(self.libjuju.disconnect())
@asynctest.mock.patch("juju.controller.Controller.connect")
"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)
):
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()
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()
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(
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(
@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_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(
# 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")
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)
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)
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,
)
)
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()
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()
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)
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)
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)
mock_disconnect_controller.assert_called()
mock_disconnect_model.assert_called()
- def test_succesful_exec(
+ def test_successful_exec(
self,
mock_get_action_status,
mock_get_action_output,
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_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")
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_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_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")
# 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):
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()
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
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"]
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"]
models = self.loop.run_until_complete(self.libjuju.list_models("mdl"))
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"]
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_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_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"]
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()
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_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()
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):
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)
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(
),
)
- 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 = ""
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)
- self.assertEqual(
- credential,
- juju.client._definitions.CloudCredential(
- attrs={"ClientCertificateData": "cacert", "Token": "Token"},
- auth_type="certificate",
- ),
+ credential = self.libjuju.get_k8s_cloud_credential(
+ mock_configuration,
+ self.cert_data,
+ self.token,
)
-
- 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",
+ attrs={"ClientCertificateData": self.cert_data, "Token": self.token},
+ auth_type="certificate",
),
)
- @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"
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_successful_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)
+
+
+@asynctest.mock.patch("juju.model.Model.machines", new_callable=asynctest.PropertyMock)
+class GetMachineInfoTest(LibjujuTestCase):
+ def setUp(self):
+ super(GetMachineInfoTest, self).setUp()
+
+ def test_successful(
+ self,
+ mock_machines,
+ ):
+ machine_id = "existing_machine"
+ model = juju.model.Model()
+ mock_machines.return_value = {"existing_machine": FakeManualMachine()}
+ machine, series = self.libjuju._get_machine_info(
+ machine_id=machine_id,
+ model=model,
+ )
+ self.assertIsNotNone(machine, series)
+
+ def test_exception(
+ self,
+ mock_machines,
+ ):
+ machine_id = "not_existing_machine"
+ machine = series = None
+ model = juju.model.Model()
+ mock_machines.return_value = {"existing_machine": FakeManualMachine()}
+ with self.assertRaises(JujuMachineNotFound):
+ machine, series = self.libjuju._get_machine_info(
+ machine_id=machine_id,
+ model=model,
+ )
+ self.assertIsNone(machine, series)
+
+
+class GetUnitTest(LibjujuTestCase):
+ def setUp(self):
+ super(GetUnitTest, self).setUp()
+
+ def test_successful(self):
+ result = self.libjuju._get_unit(FakeApplication(), "existing_machine_id")
+ self.assertIsInstance(result, FakeUnit)
+
+ def test_return_none(self):
+ result = self.libjuju._get_unit(FakeApplication(), "not_existing_machine_id")
+ self.assertIsNone(result)
+
+
+@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 CheckApplicationExists(LibjujuTestCase):
+ def setUp(self):
+ super(CheckApplicationExists, self).setUp()
+
+ def test_successful(
+ self,
+ 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()
+ result = self.loop.run_until_complete(
+ self.libjuju.check_application_exists(
+ "model",
+ "app",
+ )
+ )
+ self.assertEqual(result, True)
+
+ mock_get_application.assert_called_once()
+ mock_get_controller.assert_called_once()
+ mock_get_model.assert_called_once()
+ mock_disconnect_controller.assert_called_once()
+ mock_disconnect_model.assert_called_once()
+
+ def test_no_application(
+ self,
+ 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 = None
+ result = self.loop.run_until_complete(
+ self.libjuju.check_application_exists(
+ "model",
+ "app",
+ )
+ )
+ self.assertEqual(result, False)
+
+ mock_get_application.assert_called_once()
+ 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")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_machine_info")
+class AddUnitTest(LibjujuTestCase):
+ def setUp(self):
+ super(AddUnitTest, self).setUp()
+
+ @asynctest.mock.patch("n2vc.juju_watcher.JujuModelWatcher.wait_for")
+ @asynctest.mock.patch("asyncio.sleep")
+ def test_successful(
+ self,
+ mock_sleep,
+ mock_wait_for,
+ mock_get_machine_info,
+ 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_get_machine_info.return_value = FakeMachine(), "series"
+ self.loop.run_until_complete(
+ self.libjuju.add_unit(
+ "existing_app",
+ "model",
+ "machine",
+ )
+ )
+
+ mock_wait_for.assert_called_once()
+ mock_get_application.assert_called_once()
+ mock_get_controller.assert_called_once()
+ mock_get_model.assert_called_once()
+ mock_disconnect_controller.assert_called_once()
+ mock_disconnect_model.assert_called_once()
+
+ def test_no_app(
+ self,
+ mock_get_machine_info,
+ 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 = None
+ with self.assertRaises(JujuApplicationNotFound):
+ self.loop.run_until_complete(
+ self.libjuju.add_unit(
+ "existing_app",
+ "model",
+ "machine",
+ )
+ )
+
+ mock_get_application.assert_called_once()
+ mock_get_controller.assert_called_once()
+ mock_get_model.assert_called_once()
+ mock_disconnect_controller.assert_called_once()
+ mock_disconnect_model.assert_called_once()
+
+ def test_no_machine(
+ self,
+ mock_get_machine_info,
+ 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_get_machine_info.side_effect = JujuMachineNotFound()
+ with self.assertRaises(JujuMachineNotFound):
+ self.loop.run_until_complete(
+ self.libjuju.add_unit(
+ "existing_app",
+ "model",
+ "machine",
+ )
+ )
+
+ mock_get_application.assert_called_once()
+ 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")
+@asynctest.mock.patch("n2vc.libjuju.Libjuju._get_unit")
+class DestroyUnitTest(LibjujuTestCase):
+ def setUp(self):
+ super(DestroyUnitTest, self).setUp()
+
+ @asynctest.mock.patch("asyncio.sleep")
+ def test_successful(
+ self,
+ mock_sleep,
+ mock_get_unit,
+ 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()
+
+ self.loop.run_until_complete(
+ self.libjuju.destroy_unit("app", "model", "machine", 0)
+ )
+
+ mock_get_unit.assert_called()
+ mock_get_application.assert_called_once()
+ mock_get_controller.assert_called_once()
+ mock_get_model.assert_called_once()
+ mock_disconnect_controller.assert_called_once()
+ mock_disconnect_model.assert_called_once()
+
+ def test_no_app(
+ self,
+ mock_get_unit,
+ 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 = None
+
+ with self.assertRaises(JujuApplicationNotFound):
+ self.loop.run_until_complete(
+ self.libjuju.destroy_unit("app", "model", "machine")
+ )
+
+ mock_get_application.assert_called_once()
+ mock_get_controller.assert_called_once()
+ mock_get_model.assert_called_once()
+ mock_disconnect_controller.assert_called_once()
+ mock_disconnect_model.assert_called_once()
+
+ def test_no_unit(
+ self,
+ mock_get_unit,
+ 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_get_unit.return_value = None
+
+ with self.assertRaises(JujuError):
+ self.loop.run_until_complete(
+ self.libjuju.destroy_unit("app", "model", "machine")
+ )
+
+ mock_get_unit.assert_called_once()
+ mock_get_application.assert_called_once()
+ mock_get_controller.assert_called_once()
+ mock_get_model.assert_called_once()
+ mock_disconnect_controller.assert_called_once()
+ mock_disconnect_model.assert_called_once()