def test_additional_vars(self, keystone_version):
deployment = self.deployments[keystone_version]
deployment["extra"] = {}
existing.ExistingCloud(deployment).validate()
deployment["extra"] = {"some_var": "some_value"}
existing.ExistingCloud(deployment).validate()
deployment["extra"] = ["item1", "item2"]
existing.ExistingCloud(deployment).validate()
def test_deploy(self, keystone_version):
deployment = self.deployments[keystone_version]
engine = existing.ExistingCloud(deployment)
credentials = engine.deploy()
admin_credential = deployment["config"].copy()
admin_credential.pop("type")
admin_credential["endpoint"] = None
admin_credential.update(admin_credential.pop("admin"))
actual_credentials = credentials["admin"].to_dict()
if keystone_version == "v3":
# NOTE(andreykurilin): credentials obj uses `tenant_name` for both
# keystone v2 and v3. It works perfectly for rally code (no
# contradictions and misunderstandings ), but in case of checking
# credentials.to_dict with data from database (where we use
# project_name for keystone v3 config and tenant_name for
# keystone v2), we need to transform vars.
admin_credential["tenant_name"] = admin_credential.pop(
"project_name")
else:
# NOTE(andreykurilin): there are no domain related variables in v2,
# so we need to pop them from credentials.to_dict()
actual_credentials.pop("domain_name")
actual_credentials.pop("user_domain_name")
actual_credentials.pop("admin_domain_name")
actual_credentials.pop("project_domain_name")
self.assertEqual(admin_credential, actual_credentials)
self.assertEqual([], credentials["users"])
def test_deploy_abstract(self):
deployment = self.deployments["abstract"]
engine = existing.ExistingCloud(deployment)
credentials = engine.deploy()
self.assertEqual(1, len(credentials))
self.assertIn("openstack", credentials)
self.assertEqual(1, len(credentials["openstack"]))
credentials = credentials["openstack"][0]
self.assertEqual([], credentials["users"])
admin_credential = credentials["admin"]
self.assertEqual(
{
"auth_url": "http://example.net:5000/v2.0/",
"domain_name": None,
"endpoint": None,
"endpoint_type": "internal",
"https_cacert": "cacert",
"https_insecure": False,
"profiler_hmac_key": None,
"profiler_conn_str": None,
"password": "******",
"permission": "admin",
"project_domain_name": None,
"region_name": "RegionOne",
"tenant_name": "demo",
"user_domain_name": None,
"username": "******"
}, admin_credential)
def test_deploy(self):
engine = existing.ExistingCloud(self.deployment)
credentials = engine.deploy()
admin_credential = self.deployment["config"].copy()
admin_credential.pop("type")
admin_credential["endpoint"] = None
admin_credential.update(admin_credential.pop("admin"))
self.assertEqual(admin_credential, credentials["admin"].to_dict())
self.assertEqual([], credentials["users"])
def test_deploy(self):
engine = existing.ExistingCloud(self.deployment)
endpoints = engine.deploy()
admin_endpoint = self.deployment["config"].copy()
admin_endpoint.pop("type")
admin_endpoint["endpoint"] = None
admin_endpoint.update(admin_endpoint.pop("admin"))
self.assertEqual(admin_endpoint, endpoints["admin"].to_dict())
self.assertEqual([], endpoints["users"])
def _check_32fada9b2fde(self, engine, data):
self.assertEqual("32fada9b2fde",
api.get_backend().schema_revision(engine=engine))
original_deployments = self._32fada9b2fde_deployments
deployment_table = db_utils.get_table(engine, "deployments")
with engine.connect() as conn:
deployments_found = conn.execute(
deployment_table.select()).fetchall()
for deployment in deployments_found:
# check deployment
self.assertIn(deployment.uuid, original_deployments)
self.assertIn(deployment.name, original_deployments)
config = json.loads(deployment.config)
if config != original_deployments[deployment.uuid]:
if deployment.uuid.startswith("should-not-be-changed"):
self.fail("Config of deployment '%s' is changes, but "
"should not." % deployment.uuid)
if "admin_domain_name" in deployment.config:
self.fail("Config of deployment '%s' should not "
"contain `admin_domain_name` field." %
deployment.uuid)
endpoint_type = (original_deployments[deployment.uuid].get(
"endpoint_type"))
if endpoint_type in (None, "public"):
self.assertNotIn("endpoint_type", config)
else:
self.assertIn("endpoint_type", config)
self.assertEqual(endpoint_type,
config["endpoint_type"])
existing.ExistingCloud({"config": config}).validate()
else:
if not deployment.uuid.startswith("should-not-be-changed"):
self.fail("Config of deployment '%s' is not changes, "
"but should." % deployment.uuid)
# this deployment created at _pre_upgrade step is not needed
# anymore and we can remove it
conn.execute(deployment_table.delete().where(
deployment_table.c.uuid == deployment.uuid))
def test_cleanup(self):
existing.ExistingCloud(self.deployment).cleanup()
def test_invalid_config(self):
self.deployment["config"]["admin"] = 42
engine = existing.ExistingCloud(self.deployment)
self.assertRaises(jsonschema.ValidationError,
engine.validate)
def test_init(self):
existing.ExistingCloud(self.deployment)
def test_invalid_config(self, keystone_version):
deployment = self.deployments[keystone_version]
deployment["config"]["admin"] = 42
engine = existing.ExistingCloud(deployment)
self.assertRaises(jsonschema.ValidationError, engine.validate)
def test_init_and_valid_config(self, keystone_version):
engine = existing.ExistingCloud(self.deployments[keystone_version])
engine.validate()
def test_cleanup(self, keystone_version):
existing.ExistingCloud(self.deployments[keystone_version]).cleanup()
