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