def test_init(self, mock_env_manager_create): objects.Deployment(mock.MagicMock(data={"platforms": {}, "spec": {}})) self.assertFalse(mock_env_manager_create.called) deploy = objects.Deployment() mock_env_manager_create.assert_called_once_with( name=None, description="", spec={}, extras={} ) self.assertEqual(mock_env_manager_create.return_value.uuid, deploy["uuid"])
def test_get_platforms(self): deploy = objects.Deployment(deployment=self.env) self.assertEqual([], list(deploy.get_platforms())) self.env.data["platforms"] = { "openstack": {"platform_name": "openstack", "platform_data": {}}, "foo": {"platform_name": "foo", "platform_data": {}} } deploy = objects.Deployment(deployment=self.env) self.assertEqual({"openstack", "foo"}, set(deploy.get_platforms()))
def test_getitem(self): class FakeEnvManager(object): @property def status(self): return env_mgr.STATUS.READY @property def data(self): return { "created_at": dt.datetime(2017, 3, 10, 9, 5, 9, 68652), "updated_at": dt.datetime(2017, 3, 10, 9, 5, 10, 117427), "id": 1, "name": "foo_env_name", "uuid": "eeecf2c6-8b5d-4ed7-92e5-b7cdc335e885", "platforms": {}, "extras": { "foo": "bar" }, "spec": { "existing@openstack": { "endpoint": None, "region_name": "FooRegionOne", "https_insecure": False, "admin": { "username": "******", "password": "******", "user_domain_name": "Default", "project_name": "foo_prj_name", "project_domain_name": "Default" }, "https_cacert": "", "endpoint_type": None, "auth_url": "foo_auth_url" } } } deploy = objects.Deployment(deployment=FakeEnvManager()) self.assertEqual("deploy->finished", deploy["status"]) self.assertEqual({"foo": "bar"}, deploy["extra"]) self.assertEqual( { "openstack": { "admin": { "password": "******", "project_domain_name": "Default", "project_name": "foo_prj_name", "user_domain_name": "Default", "username": "******" }, "auth_url": "foo_auth_url", "endpoint": None, "endpoint_type": None, "https_cacert": "", "https_insecure": False, "region_name": "FooRegionOne" } }, deploy["config"])
def test_networks(self, mock_deployment_get, mock_nova_create_client, mock_struct, mock_print_list): self.fake_nova_client.networks.create(1234) fake_network = list(self.fake_nova_client.networks.cache.values())[0] fake_network.label = "fakenet" fake_network.cidr = "10.0.0.0/24" mock_nova_create_client.return_value = self.fake_nova_client mock_deployment_get.return_value = objects.Deployment({ "admin": self.admin_credential, "users": [self.user_credentials, self.user_credentials] }) self.show.networks(self.fake_deployment_id) mock_deployment_get.assert_called_once_with(self.fake_deployment_id) mock_nova_create_client.assert_has_calls([mock.call()] * 3) self.assertEqual(3, mock_nova_create_client.call_count) headers = ["ID", "Label", "CIDR"] fake_data = dict( zip(headers, [fake_network.id, fake_network.label, fake_network.cidr]) ) mock_struct.assert_has_calls([mock.call(**fake_data)] * 3) mixed_case_fields = ["ID", "Label", "CIDR"] mock_print_list.assert_has_calls([mock.call( [mock_struct()], fields=headers, mixed_case_fields=mixed_case_fields )] * 3)
def test_update_credentials(self, mock_deployment_update): mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) credentials = { "foo": [{ "admin": { "fake_admin": True }, "users": [{ "fake_user": True }] }] } deploy.update_credentials(credentials) mock_deployment_update.assert_called_once_with( self.deployment["uuid"], { "credentials": { "foo": [{ "admin": { "fake_admin": True }, "users": [{ "fake_user": True }] }] } })
def _deploy_node(self, config): deployment = objects.Deployment(config=config, parent_uuid=self.deployment["uuid"]) deployer = engine.Engine.get_engine(config["type"], deployment) with deployer: endpoints = deployer.make_deploy() return deployer, endpoints
def test_get_credentials_for(self, mock_credential_get): credential_cls = mock_credential_get.return_value credential_inst = credential_cls.return_value credentials = { "foo": [{ "admin": { "fake_admin": True }, "users": [{ "fake_user": True }] }] } self.deployment["credentials"] = credentials deploy = objects.Deployment(deployment=self.deployment) creds = deploy.get_credentials_for("foo") mock_credential_get.assert_called_once_with("foo") credential_cls.assert_has_calls(( mock.call(fake_admin=True), mock.call(fake_user=True), )) self.assertEqual({ "admin": credential_inst, "users": [credential_inst] }, creds)
def create(cls, config, name): """Create a deployment. :param config: a dict with deployment configuration :param name: a str represents a name of the deployment :returns: Deployment object """ try: deployment = objects.Deployment(name=name, config=config) except exceptions.DeploymentNameExists as e: if logging.is_debug(): LOG.exception(e) raise deployer = deploy_engine.Engine.get_engine( deployment["config"]["type"], deployment) try: deployer.validate() except jsonschema.ValidationError: LOG.error( _("Deployment %s: Schema validation error.") % deployment["uuid"]) deployment.update_status(consts.DeployStatus.DEPLOY_FAILED) raise with deployer: endpoints = deployer.make_deploy() deployment.update_endpoints(endpoints) return deployment
def test_images(self, mock_deployment_get, mock_glance_create_client, mock_struct, mock_pretty_float_formatter, mock_print_list, mock_print): self.fake_glance_client.images.create("image", None, None, None) fake_image = list(self.fake_glance_client.images.cache.values())[0] fake_image.size = 1 mock_glance_create_client.return_value = self.fake_glance_client mock_deployment_get.return_value = objects.Deployment({ "admin": self.admin_credential, "users": [self.user_credentials, self.user_credentials] }) self.show.images(self.fake_deployment_id) mock_deployment_get.assert_called_once_with(self.fake_deployment_id) mock_glance_create_client.assert_has_calls([mock.call()] * 3) self.assertEqual(3, mock_glance_create_client.call_count) headers = ["UUID", "Name", "Size (B)"] fake_data = dict( zip(headers, [fake_image.id, fake_image.name, fake_image.size]) ) mock_struct.assert_has_calls([mock.call(**fake_data)] * 3) fake_formatters = {"Size (B)": mock_pretty_float_formatter()} mixed_case_fields = ["UUID", "Name"] mock_print_list.assert_has_calls([mock.call( [mock_struct()], fields=headers, formatters=fake_formatters, mixed_case_fields=mixed_case_fields )] * 3) self.assertEqual(3, mock_print.call_count)
def test_update_endpoints(self, mock_deployment_update): mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) endpoints = { "admin": objects.Credential("url", "user", "pwd", "tenant", consts.EndpointPermission.ADMIN), "users": [ objects.Credential("url1", "user1", "pwd1", "tenant1", consts.EndpointPermission.USER), objects.Credential("url2", "user2", "pwd2", "tenant2", consts.EndpointPermission.USER), ] } expected_users = [ u.to_dict(include_permission=True) for u in endpoints["users"] ] deploy.update_endpoints(endpoints) mock_deployment_update.assert_called_once_with( self.deployment["uuid"], { "admin": endpoints["admin"].to_dict(include_permission=True), "users": expected_users })
def test_secgroups(self, mock_deployment_get, mock_nova_create_client, mock_struct, mock_print_list): self.fake_nova_client.security_groups.create("othersg") fake_secgroup = list( self.fake_nova_client.security_groups.cache.values())[0] fake_secgroup.id = 0 fake_secgroup2 = list( self.fake_nova_client.security_groups.cache.values())[1] fake_secgroup2.id = 1 mock_nova_create_client.return_value = self.fake_nova_client mock_deployment_get.return_value = objects.Deployment({ "admin": self.admin_credential, "users": [self.user_credentials] }) self.show.secgroups(self.fake_deployment_id) mock_deployment_get.assert_called_once_with(self.fake_deployment_id) mock_nova_create_client.assert_has_calls([mock.call()] * 2) self.assertEqual(2, mock_nova_create_client.call_count) headers = ["ID", "Name", "Description"] fake_data = [fake_secgroup.id, fake_secgroup.name, ""] fake_data2 = [fake_secgroup2.id, fake_secgroup2.name, ""] calls = [mock.call(**dict(zip(headers, fake_data2))), mock.call(**dict(zip(headers, fake_data)))] mock_struct.assert_has_calls(calls * 2, any_order=True) mixed_case_fields = ["ID", "Name", "Description"] mock_print_list.assert_has_calls([mock.call( [mock_struct(), mock_struct()], fields=headers, mixed_case_fields=mixed_case_fields )] * 2)
def test_keypairs(self, mock_deployment_get, mock_nova_create_client, mock_struct, mock_print_list): self.fake_nova_client.keypairs.create("keypair") fake_keypair = list(self.fake_nova_client.keypairs.cache.values())[0] fake_keypair.fingerprint = "84:87:58" mock_nova_create_client.return_value = self.fake_nova_client mock_deployment_get.return_value = objects.Deployment({ "admin": self.admin_credential, "users": [self.user_credentials, self.user_credentials] }) self.show.keypairs(self.fake_deployment_id) mock_deployment_get.assert_called_once_with(self.fake_deployment_id) mock_nova_create_client.assert_has_calls([mock.call()] * 3) self.assertEqual(3, mock_nova_create_client.call_count) headers = ["Name", "Fingerprint"] fake_data = dict( zip(headers, [fake_keypair.name, fake_keypair.fingerprint]) ) mock_struct.assert_has_calls([mock.call(**fake_data)] * 3) mixed_case_fields = ["Name", "Fingerprint"] mock_print_list.assert_has_calls([mock.call( [mock_struct()], fields=headers, mixed_case_fields=mixed_case_fields )] * 3)
def test_update_name(self, mock_deployment_update): mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) deploy.update_name("new_name") mock_deployment_update.assert_called_once_with( self.deployment["uuid"], {"name": "new_name"}, )
def _deploy_node(self, config, name): deployment = objects.Deployment(config=config, parent_uuid=self.deployment["uuid"]) deployment.update_name(name) deployer = engine.Engine.get_engine(config["type"], deployment) with deployer: credentials = deployer.make_deploy() return deployer, credentials
def test_get_credentials_for(self, mock_get_all_credentials): mock_get_all_credentials.return_value = { "foo": ["bar"] } deploy = objects.Deployment(deployment=self.env) self.assertEqual("bar", deploy.get_credentials_for("foo"))
def test_update_status(self, mock_deployment_update): mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) deploy.update_status(consts.DeployStatus.DEPLOY_FAILED) mock_deployment_update.assert_called_once_with( self.deployment["uuid"], {"status": consts.DeployStatus.DEPLOY_FAILED}, )
def test_update(self, mock_deployment_create, mock_deployment_update): mock_deployment_create.return_value = self.deployment mock_deployment_update.return_value = {"opt": "val2"} deploy = objects.Deployment(opt="val1") deploy._update({"opt": "val2"}) mock_deployment_update.assert_called_once_with(self.deployment["uuid"], {"opt": "val2"}) self.assertEqual(deploy["opt"], "val2")
def test_update_empty_endpoints(self, mock_deployment_update): mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) deploy.update_endpoints({}) mock_deployment_update.assert_called_once_with(self.deployment["uuid"], { "admin": {}, "users": [] })
def test_to_dict(self): self.deployment = { "status": "deploy->finished", "parent_uuid": None, "updated_at": dt.datetime(2017, 3, 10, 9, 5, 9, 117427), "completed_at": dt.datetime(2017, 3, 10, 12, 5, 9, 94981), "credentials": { "openstack": [{ "admin": { "username": "******", "endpoint": None, "region_name": "FooRegionOne", "https_insecure": False, "permission": "foo_perm", "tenant_name": "foo_tenant", "user_domain_name": "Default", "https_cacert": "", "domain_name": None, "endpoint_type": None, "auth_url": "foo_auth_url", "password": "******", "project_domain_name": "Default" }, "users": [] }] }, "started_at": dt.datetime(2017, 3, 10, 12, 5, 9, 78779), "id": 1, "name": "foo_deployment_name", "uuid": "eeecf2c6-8b5d-4ed7-92e5-b7cdc335e885", "created_at": dt.datetime(2017, 3, 10, 9, 5, 9, 68652), "config": { "endpoint": None, "region_name": "FooRegionOne", "https_insecure": False, "admin": { "username": "******", "password": "******", "user_domain_name": "Default", "project_name": "foo_prj_name", "project_domain_name": "Default" }, "https_cacert": "", "endpoint_type": None, "auth_url": "foo_auth_url", "type": "ExistingCloud" } } deploy = objects.Deployment(deployment=self.deployment) expected_result = deploy.to_dict() for field in [ "created_at", "completed_at", "started_at", "updated_at" ]: self.deployment[field] = self.deployment[field].strftime( self.TIME_FORMAT) self.assertEqual(expected_result, self.deployment)
def test_update_set_completed(self, mock_deployment_update, mock_datetime): mock_datetime.now = mock.Mock(return_value="fake_time") mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) deploy.set_completed() mock_deployment_update.assert_called_once_with( self.deployment["uuid"], { "completed_at": "fake_time", "status": consts.DeployStatus.DEPLOY_FINISHED })
def test_get_deprecated(self, mock_open_stack_credential): credential_inst = mock_open_stack_credential.return_value deploy = objects.Deployment(deployment=self.env) deploy._all_credentials = { "openstack": [{"admin": {"fake_admin": True}, "users": [{"fake_user": True}]}]} self.assertEqual(credential_inst, deploy["admin"]) self.assertEqual([credential_inst], deploy["users"])
def test_update_config(self, mock_deployment_update): mock_deployment_update.return_value = self.deployment deploy = objects.Deployment(deployment=self.deployment) deploy.update_config({"opt": "val"}) mock_deployment_update.assert_called_once_with( self.deployment["uuid"], {"config": { "opt": "val" }}, )
def test_verify_connections(self): deploy = objects.Deployment(deployment=self.env) self.env.check_health.return_value = {"foo": {"available": True}} deploy.verify_connections() self.env.check_health.assert_called_once_with() self.env.check_health.return_value = {"foo": {"available": False, "message": "Ooops"}} e = self.assertRaises(exceptions.RallyException, deploy.verify_connections) self.assertEqual("Platform foo is not available: Ooops.", "%s" % e)
def test_get_platforms(self): self.deployment["credentials"] = { "foo": { "admin": None, "users": [] }, "bar": { "admin": None, "users": [] } } deploy = objects.Deployment(deployment=self.deployment) self.assertEqual({"foo", "bar"}, set(deploy.get_platforms()))
def test_verify_connections(self, mock_get_all_credentials): creds = [mock.MagicMock(), mock.MagicMock(), mock.MagicMock()] mock_get_all_credentials.return_value = { "foo": [{ "admin": creds[0], "users": [creds[1], creds[2]] }] } deploy = objects.Deployment(deployment=self.deployment) deploy.verify_connections() for c in creds: c.verify_connection.assert_called_once_with()
def test_get_credentials_for(self): credentials = { "foo": [{ "admin": { "fake_admin": True }, "users": [{ "fake_user": True }] }] } self.deployment["credentials"] = credentials deploy = objects.Deployment(deployment=self.deployment) creds = deploy.get_credentials_for("foo") self.assertEqual(credentials["foo"][0], creds)
def test_get_deprecated(self): credentials = { "openstack": [{ "admin": { "fake_admin": True }, "users": [{ "fake_user": True }] }] } self.deployment["credentials"] = credentials deploy = objects.Deployment(deployment=self.deployment) self.assertEqual(credentials["openstack"][0]["admin"], deploy["admin"]) self.assertEqual(credentials["openstack"][0]["users"], deploy["users"])
def test_to_dict(self): env = mock.Mock(status=env_mgr.STATUS.READY, data={ "created_at": dt.datetime(2017, 3, 10, 9, 5, 8, 0).isoformat(), "updated_at": dt.datetime(2017, 3, 10, 9, 5, 9, 0).isoformat(), "id": 1, "name": "foo_env_name", "uuid": "eeecf2c6-8b5d-4ed7-92e5-b7cdc335e885", "platforms": {}, "spec": { "existing@openstack": { "endpoint": None, "region_name": "FooRegionOne", "https_insecure": False, "admin": { "username": "******", "password": "******", "user_domain_name": "Default", "project_name": "foo_prj_name", "project_domain_name": "Default" }, "https_cacert": "", "endpoint_type": None, "auth_url": "foo_auth_url" } } }) deploy = objects.Deployment(deployment=env) config = {"openstack": env.data["spec"]["existing@openstack"]} self.assertEqual( { "created_at": "2017-03-10T09:05:08", "started_at": "2017-03-10T09:05:08", "updated_at": "2017-03-10T09:05:09", "completed_at": "n/a", "uuid": "eeecf2c6-8b5d-4ed7-92e5-b7cdc335e885", "name": "foo_env_name", "parent_uuid": None, "status": "deploy->finished", "config": config, "credentials": {} }, deploy.to_dict())
def test_get_validation_context(self, mock_credential_get): credential_cls = mock_credential_get.return_value credential_cls.get_validation_context.side_effect = [{ "foo_test": "test" }, { "boo_test": "boo" }] credentials = {"foo": [], "boo": []} self.deployment["credentials"] = credentials deploy = objects.Deployment(deployment=self.deployment) self.assertEqual({ "foo_test": "test", "boo_test": "boo" }, deploy.get_validation_context()) mock_credential_get.assert_has_calls( [mock.call("foo"), mock.call("boo")], any_order=True)
def _deploy_first(self, lxc_host, name, distribution, release): lxc_host.prepare() lxc_host.create_container(name, distribution, release) lxc_host.start_containers() items = lxc_host.get_server_object(name).get_credentials().items() # filter out all keys where value is None credentials = dict(filter(lambda x: x[1] is not None, items)) engine_config = self.config["engine"].copy() engine_config["provider"] = { "type": "DummyProvider", "credentials": [credentials] } deployment = objects.Deployment(config=engine_config, parent_uuid=self.deployment["uuid"]) deployer = engine.Engine.get_engine(engine_config["name"], deployment) deployer.deploy() lxc_host.stop_containers()