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()
