def test_simple_software_configuration(self):
"""Test simple software configuration
Scenario:
1. Create environment with name specified
2. Add ApacheHTTPServer application to the instance with specific
user name
3. Deploy environment
4. Make sure that deployment finished successfully
5. Check that application is accessible
6. Check that environment deployed with specific user name
7. Delete environment
"""
post_body = self.apache(userName=utils.generate_name('user'))
username = post_body["userName"]
environment_name = utils.generate_name('SSC-murano')
environment = self.application_catalog_client.create_environment(
name=environment_name)
self.addCleanup(self.environment_delete, environment['id'])
session = self.application_catalog_client.create_session(
environment['id'])
self.assertEqual(environment['id'], session['environment_id'])
self.application_catalog_client.\
create_service(environment['id'], session['id'], post_body)
self.deploy_environment(environment, session)
self.status_check(environment['id'],
[[post_body['instance']['name'], 22, 80]])
resp = self.check_path(environment['id'], '',
post_body['instance']['name'])
self.assertIn(
username, resp.text, "Required information not found in "
"response from server")
def vm_cinder(self, attributes=None, userName=None, flavor='m1.tiny'):
post_body = {
"instance": {
"flavor": flavor,
"image": self.cirros_image,
"assignFloatingIp": True,
"availabilityZone": "nova",
"volumes": attributes,
"?": {
"type": "io.murano.resources.LinuxMuranoInstance",
"id": utils.generate_uuid()
},
"name": utils.generate_name("testMurano")
},
"name": utils.generate_name("VM"),
"userName": userName,
"?": {
"_{id}".format(id=utils.generate_uuid()): {
"name": "VM"
},
"type": "io.murano.apps.test.VM",
"id": utils.generate_uuid()
}
}
return post_body
def vm_test(self, **kwargs):
instance = {
"flavor": "m1.tiny",
"image": self.cirros_image,
"assignFloatingIp": True,
"availabilityZone": "nova",
"?": {
"type": "io.murano.resources.LinuxMuranoInstance",
"id": utils.generate_uuid()
},
"name": utils.generate_name("testMurano")
}
if kwargs.get('securityGroups'):
instance['securityGroups'] = kwargs.get('securityGroups')
return {
"instance": instance,
"name": utils.generate_name("VM"),
"?": {
"_{id}".format(id=utils.generate_uuid()): {
"name": "VM"
},
"type": "io.murano.apps.test.VM",
"id": utils.generate_uuid()
}
}
def apache_cinder(self,
attributes=None,
userName=None,
flavor='m1.medium'):
post_body = {
"instance": {
"flavor": flavor,
"image": self.linux_image,
"assignFloatingIp": True,
"availabilityZone": "nova",
"volumes": attributes,
"?": {
"type": "io.murano.resources.LinuxMuranoInstance",
"id": utils.generate_uuid()
},
"name": utils.generate_name("testMurano")
},
"name": utils.generate_name("ApacheHTTPServer"),
"userName": userName,
"?": {
"_{id}".format(id=utils.generate_uuid()): {
"name": "ApacheHTTPServer"
},
"type": "io.murano.apps.test.ApacheHttpServerCustom",
"id": utils.generate_uuid()
}
}
return post_body
def resource_setup(cls):
if not CONF.application_catalog.glare_backend:
msg = ("Murano is not using GLARE backend. "
"Skipping GLARE tests.")
raise cls.skipException(msg)
super(TestVersioning, cls).resource_setup()
application_name = utils.generate_name('package_test')
# create first package
version1 = '1.0.0'
package1, _ = cls.upload_package(application_name, version=version1)
# create second package
version2 = '2.0.0'
package2, path1 = cls.upload_package(application_name,
version=version2)
# create package with require >=2.0.0 for 2.0.0 package
expected_version = '>=2.0.0'
main_app_name = utils.generate_name('main_package_test')
require = [(package2['name'], expected_version)]
package3, path2 = cls.upload_package(main_app_name, require=require)
cls.packages = {
'1.0.0': package1,
'2.0.0': package2,
'require_for_2.0.0': package3,
}
cls.abs_archive_paths = [path1, path2]
def resource_setup(cls):
if not CONF.application_catalog.deployment_tests or \
not CONF.application_catalog.linux_image:
msg = "Application Catalog Scenario Deployment Tests will be " \
"skipped."
raise cls.skipException(msg)
super(TestMuranoDeployment, cls).resource_setup()
cls.abs_archive_path = [None] * 3
cls.packages = [None] * 3
application_name = utils.generate_name('Apache')
cls.abs_archive_path[0], dir_with_archive, archive_name = \
utils.prepare_package(
application_name,
app='io.murano.apps.test.ApacheHttpServerCustom',
manifest_required=False)
if CONF.application_catalog.glare_backend:
cls.client = cls.artifacts_client
else:
cls.client = cls.application_catalog_client
cls.packages[0] = cls.client.upload_package(application_name,
archive_name,
dir_with_archive, {
"categories": ["Web"],
"tags": ["test"]
})
application_name = utils.generate_name('Lighttpd')
cls.abs_archive_path[1], dir_with_archive, archive_name = \
utils.prepare_package(
application_name,
app='io.murano.apps.test.Lighttpd',
manifest_required=False)
cls.packages[1] = cls.client.upload_package(application_name,
archive_name,
dir_with_archive, {
"categories": ["Web"],
"tags": ["test"]
})
application_name = utils.generate_name('UpdateExecutor')
cls.abs_archive_path[2], dir_with_archive, archive_name = \
utils.prepare_package(
application_name,
app='io.murano.apps.test.UpdateExecutor',
manifest_required=False)
cls.packages[2] = cls.client.upload_package(application_name,
archive_name,
dir_with_archive, {
"categories": ["Web"],
"tags": ["test"]
})
def resource_setup(cls):
super(TestCategories, cls).resource_setup()
application_name = utils.generate_name(cls.__name__)
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
name = utils.generate_name(cls.__name__)
cls.category = cls.application_catalog_client.create_category(name)
def resource_setup(cls):
super(TestCategories, cls).resource_setup()
application_name = utils.generate_name(cls.__name__)
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive, {
"categories": [],
"tags": [],
'is_public': False
})
name = utils.generate_name(cls.__name__)
cls.category = cls.application_catalog_client.create_category(name)
def test_get_public_private_both_env_templates(self):
name = utils.generate_name('get_public_private_both')
public_env_template = self.application_catalog_client.\
create_public_env_template(name)
self.addCleanup(self.application_catalog_client.delete_env_template,
public_env_template['id'])
self.assertTrue(public_env_template['is_public'])
private_name = utils.generate_name('get_public_private_both')
private_env_template = self.application_catalog_client.\
create_env_template(private_name)
self.addCleanup(self.application_catalog_client.delete_env_template,
private_env_template['id'])
self.assertFalse(private_env_template['is_public'])
private_name_alt = utils.generate_name('get_public_private_both')
private_alt_env_template = self.alt_client.\
create_env_template(private_name_alt)
self.addCleanup(self.alt_client.delete_env_template,
private_alt_env_template['id'])
public_env_templates = self.application_catalog_client.\
get_public_env_templates_list()
self.assertIn(public_env_template, public_env_templates)
self.assertNotIn(private_env_template, public_env_templates)
self.assertNotIn(private_alt_env_template, public_env_templates)
private_env_templates = self.application_catalog_client.\
get_private_env_templates_list()
self.assertNotIn(public_env_template, private_env_templates)
self.assertIn(private_env_template, private_env_templates)
self.assertNotIn(private_alt_env_template, private_env_templates)
env_templates = self.application_catalog_client.\
get_env_templates_list()
self.assertIn(public_env_template, env_templates)
self.assertIn(private_env_template, env_templates)
self.assertNotIn(private_alt_env_template, env_templates)
alt_pub_templates = self.alt_client.get_public_env_templates_list()
self.assertIn(public_env_template, alt_pub_templates)
self.assertNotIn(private_env_template, alt_pub_templates)
self.assertNotIn(private_alt_env_template, alt_pub_templates)
alt_priv_templates = self.alt_client.get_private_env_templates_list()
self.assertNotIn(public_env_template, alt_priv_templates)
self.assertNotIn(private_env_template, alt_priv_templates)
self.assertIn(private_alt_env_template, alt_priv_templates)
alt_env_templates = self.alt_client.get_env_templates_list()
self.assertIn(public_env_template, alt_env_templates)
self.assertNotIn(private_env_template, alt_env_templates)
self.assertIn(private_alt_env_template, alt_env_templates)
def test_create_env_from_template(self):
name = utils.generate_name("create_env_from_template")
env_template = self.application_catalog_client.create_public_env_template(name)
self.addCleanup(self.application_catalog_client.delete_env_template, env_template["id"])
post_body = self._get_demo_app()
service = self.application_catalog_client.create_service_in_env_template(env_template["id"], post_body)
self.assertEqual(post_body["name"], service["name"])
env_name = utils.generate_name("create_env_from_template")
environment = self.application_catalog_client.create_env_from_template(env_template["id"], env_name)
self.addCleanup(self.application_catalog_client.delete_environment, environment["environment_id"])
self.assertIsNotNone(environment)
service_from_env = self.application_catalog_client.get_service(
environment["environment_id"], service["?"]["id"], environment["session_id"]
)
self.assertEqual(service, service_from_env)
def test_double_provision_to_the_same_space(self):
application_name = utils.generate_name('cfapi')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive, {
"categories": [],
"tags": [],
'is_public': True
})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
app_list = self.service_broker_client.get_applications_list()
app = self.service_broker_client.get_application(
application_name, app_list)
post_json = {}
instance_id = utils.generate_uuid()
space_id = utils.generate_uuid()
service = self.service_broker_client.provision(instance_id, app['id'],
app['plans'][0]['id'],
space_id, post_json)
self.wait_for_result(instance_id, 30)
self.addCleanup(self.perform_deprovision, instance_id)
self.assertIsInstance(json.loads(service), dict)
application_name = utils.generate_name('cfapi')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive, {
"categories": [],
"tags": [],
'is_public': True
})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
app_list = self.service_broker_client.get_applications_list()
app = self.service_broker_client.get_application(
application_name, app_list)
post_json = {}
instance_id = utils.generate_uuid()
service = self.service_broker_client.provision(instance_id, app['id'],
app['plans'][0]['id'],
space_id, post_json)
self.wait_for_result(instance_id, 30)
self.addCleanup(self.perform_deprovision, instance_id)
self.assertIsInstance(json.loads(service), dict)
def update_environment(self, environment_id):
uri = 'v1/environments/{0}'.format(environment_id)
name = utils.generate_name("updated_env")
post_body = {"name": name}
resp, body = self.put(uri, json.dumps(post_body))
self.expected_success(200, resp.status)
return self._parse_resp(body)
def test_clone_env_template(self):
name = utils.generate_name("clone_env_template")
cloned_template = self.alt_client.clone_env_template(self.env_template["id"], name)
self.addCleanup(self.alt_client.delete_env_template, cloned_template["id"])
self.assertEqual(name, cloned_template["name"])
template = self.alt_client.get_env_template(cloned_template["id"])
self.assertEqual(name, template["name"])
def test_create_public_env_template(self):
name = utils.generate_name("create_public_env_template")
env_template = self.application_catalog_client.create_public_env_template(name)
self.addCleanup(self.application_catalog_client.delete_env_template, env_template["id"])
self.assertEqual(name, env_template["name"])
env_temp = self.application_catalog_client.get_env_template(env_template["id"])
self.assertTrue(env_temp["is_public"])
def test_provision_with_incorrect_input(self):
"""Test provision with restricted items in object model
Test will fail on deprovision, if parameters from '?' section
will passed through service-broker.
"""
application_name = utils.generate_name('cfapi')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': True})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
app_list = self.service_broker_client.get_applications_list()
app = self.service_broker_client.get_application(application_name,
app_list)
# NOTE(freerunner): The '?' section should be cutted off during
# provision action.
post_json = {
'?': {
'type': 'io.murano.apps.{0}'.format(application_name),
'id': utils.generate_uuid()
}
}
instance_id = utils.generate_uuid()
space_id = utils.generate_uuid()
service = self.service_broker_client.provision(
instance_id, app['id'], app['plans'][0]['id'],
space_id, post_json)
self.wait_for_result(instance_id, 30)
self.addCleanup(self.perform_deprovision, instance_id)
self.assertIsInstance(json.loads(service), dict)
def test_publicize_package(self):
# Given a package that isn't public
application_name = utils.generate_name('test_publicize_package')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive, {
"categories": [],
"tags": [],
'is_public': False
})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
fetched_package = self.application_catalog_client.get_package(
package['id'])
self.assertFalse(fetched_package['is_public'])
# When package is publicized
post_body = [{"op": "replace", "path": "/is_public", "value": True}]
self.application_catalog_client.update_package(package['id'],
post_body)
# Then package becomes public
fetched_package = self.application_catalog_client.get_package(
package['id'])
self.assertTrue(fetched_package['is_public'])
def update_environment(self, environment_id):
uri = 'v1/environments/{0}'.format(environment_id)
name = utils.generate_name("updated_env")
post_body = {"name": name}
resp, body = self.put(uri, json.dumps(post_body))
self.expected_success(200, resp.status)
return self._parse_resp(body)
def test_deploy_app_with_existing_volume(self):
"""Test app deployment with existing volume
Scenario:
1. Create environment
2. Add VM application with ability to attach existing
Cinder volume to the instance
3. Deploy environment
4. Make sure that deployment finished successfully
5. Check that application is accessible
6. Check that volume is attached to the instance
7. Delete environment
"""
name = utils.generate_name('testMurano')
environment = self.application_catalog_client.\
create_environment(name)
self.addCleanup(self.environment_delete, environment['id'])
session = self.application_catalog_client.\
create_session(environment['id'])
volume_attributes = {
"/dev/vdb": {
"?": {
"type": "io.murano.resources.ExistingCinderVolume"
},
"openstackId": self.volume['id']
}
}
post_body = self.vm_cinder(attributes=volume_attributes)
self.application_catalog_client.\
create_service(environment['id'], session['id'],
post_body)
self.deploy_environment(environment, session)
self.check_volume_attached('testMurano', self.volume['id'])
def test_deploy_package_with_required_package_version(self):
"""Test deployment of package which requires package with present version.
1) Create environment.
2) Add to the environment package which requires version 2.0.0 of the
package, which is present with versions 1.0.0 and 2.0.0 in repository.
3) Deploy environment.
4) Check if deployment status ok.
"""
# create environment
environment_name = utils.generate_name('create_environment')
environment = self.application_catalog_client.create_environment(
environment_name)
self.addCleanup(self.application_catalog_client.delete_environment,
environment['id'])
# create session
session = self.application_catalog_client.create_session(
environment['id'])
object_model = self.create_obj_model(
self.packages['require_for_2.0.0'])
self.application_catalog_client.create_service(environment['id'],
session['id'],
object_model)
self.application_catalog_client.deploy_session(environment['id'],
session['id'])
deploy_result = utils.wait_for_environment_deploy(
self.application_catalog_client, environment['id'])['status']
self.assertEqual(deploy_result, 'ready')
def test_publicize_package_as_non_admin_user(self):
# Given a package that isn't public
application_name = utils.generate_name('test_publicize_package_'
'as_non_admin_user')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
# When package is publicized, then the method throws an exception
post_body = [
{
"op": "replace",
"path": "/is_public",
"value": True
}
]
self.assertRaises(exceptions.Forbidden,
self.application_catalog_client.update_package,
package['id'],
post_body)
def test_binding_instance(self):
application_name = utils.generate_name('cfapi')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': True})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
app_list = self.service_broker_client.get_applications_list()
app = self.service_broker_client.get_application(application_name,
app_list)
post_json = {}
instance_id = utils.generate_uuid()
space_id = utils.generate_uuid()
service = self.service_broker_client.provision(
instance_id, app['id'], app['plans'][0]['id'],
space_id, post_json)
self.wait_for_result(instance_id, 30)
self.addCleanup(self.perform_deprovision, instance_id)
self.assertIsInstance(json.loads(service), dict)
binding = self.service_broker_client.create_binding(instance_id)
self.assertIsInstance(binding, dict)
self.assertEqual({'uri': 'localhost'}, binding)
def resource_setup(cls):
super(TestServicesNegativeTenantIsolation, cls).resource_setup()
name = utils.generate_name(cls.__name__)
cls.environment = cls.application_catalog_client.\
create_environment(name)
cls.alt_client = cls.get_client_with_isolated_creds(
type_of_creds='alt')
def test_app_deployment(self):
"""Test app deployment
Scenario:
1. Create environment
2. Add ApacheHTTPServer application to the instance
3. Deploy environment
4. Make sure that deployment finished successfully
5. Check that application is accessible
6. Delete environment
"""
post_body = self.apache()
environment_name = utils.generate_name('Test_Murano')
environment = self.application_catalog_client.create_environment(
name=environment_name)
self.addCleanup(self.environment_delete, environment['id'])
session = self.application_catalog_client.create_session(
environment['id'])
self.assertEqual(environment['id'], session['environment_id'])
self.application_catalog_client.\
create_service(environment['id'], session['id'], post_body)
self.deploy_environment(environment, session)
self.status_check(environment['id'],
[[post_body['instance']['name'], 22, 80]])
def test_provision_with_incorrect_input(self):
"""Test provision with restricted items in object model
Test will fail on deprovision, if parameters from '?' section
will passed through service-broker.
"""
application_name = utils.generate_name('cfapi')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': True})
self.addCleanup(self.application_catalog_client.delete_package,
package['id'])
app_list = self.service_broker_client.get_applications_list()
app = self.service_broker_client.get_application(application_name,
app_list)
# NOTE(freerunner): The '?' section should be cutted off during
# provision action.
post_json = {
'?': {
'type': 'io.murano.apps.{0}'.format(application_name),
'id': utils.generate_uuid()
}
}
instance_id = utils.generate_uuid()
space_id = utils.generate_uuid()
service = self.service_broker_client.provision(
instance_id, app['id'], app['plans'][0]['id'],
space_id, post_json)
self.wait_for_result(instance_id, 30)
self.addCleanup(self.perform_deprovision, instance_id)
self.assertIsInstance(json.loads(service), dict)
def test_resources_deallocation(self):
"""Test resources deallocation
Scenario:
1. Create environment
2. Add ApacheHTTPServer application to the instance
3. Deploy environment
4. Make sure that deployment finished successfully
5. Check that application is accessible
6. Remove application from environment
7. Deploy environment
8. Check that application is accessible
9. Check that resources aren't used
10. Delete environment
"""
app_1_post_body = self.apache()
app_2_post_body = self.apache()
environment_name = utils.generate_name('Test_Murano')
environment = self.application_catalog_client.create_environment(
name=environment_name)
self.addCleanup(self.environment_delete, environment['id'])
session = self.application_catalog_client.create_session(
environment['id'])
self.assertEqual(environment['id'], session['environment_id'])
self.application_catalog_client.create_service(environment['id'],
session['id'],
app_1_post_body)
self.application_catalog_client.create_service(environment['id'],
session['id'],
app_2_post_body)
self.deploy_environment(environment, session)
self.status_check(environment['id'],
[[app_1_post_body['instance']['name'], 22, 80]])
environment = self.application_catalog_client.get_environment(
environment['id'])
app_for_remove = self.get_service(environment['id'], session['id'],
app_1_post_body['name'])
session = self.application_catalog_client.create_session(
environment['id'])
self.application_catalog_client.delete_service(
environment['id'], session['id'], app_for_remove['?']['id'])
environment = self.application_catalog_client.get_environment(
environment['id'])
self.deploy_environment(environment, session)
self.status_check(environment['id'],
[[app_2_post_body['instance']['name'], 22, 80]])
instance_name = app_1_post_body['instance']['name']
stack = self.get_stack_id(environment['id'])
template = self.get_stack_template(stack)
ip_addresses = '{0}-assigned-ip'.format(instance_name)
floating_ip = '{0}-FloatingIPaddress'.format(instance_name)
self.assertNotIn(ip_addresses, template['outputs'])
self.assertNotIn(floating_ip, template['outputs'])
self.assertNotIn(instance_name, template['resources'])
def test_create_env_template_with_a_service(self):
name = utils.generate_name("create_env_template_with_service")
post_body = self._get_demo_app()
env_template = self.application_catalog_client.create_env_template_with_services(name, post_body)
self.addCleanup(self.application_catalog_client.delete_env_template, env_template["id"])
list_services = self.application_catalog_client.get_services_list_in_env_template(env_template["id"])
self.assertIsInstance(list_services, list)
self.assertIn(post_body, list_services)
def resource_setup(cls):
super(TestEnvironmentTemplatesNegative, cls).resource_setup()
cls.name = utils.generate_name(cls.__name__)
cls.env_template = cls.application_catalog_client.\
create_env_template(cls.name)
cls.environment = cls.application_catalog_client.\
create_environment(cls.name)
cls.alt_client = cls.get_client_with_isolated_creds('alt')
def test_get_deleted_environment(self):
name = utils.generate_name('double_del_negavive')
environment = self.application_catalog_client.\
create_environment(name)
self.application_catalog_client.delete_environment(environment['id'])
self.assertRaises(exceptions.NotFound,
self.application_catalog_client.get_environment,
environment['id'])
def test_get_deleted_environment(self):
name = utils.generate_name('double_del_negavive')
environment = self.application_catalog_client.\
create_environment(name)
self.application_catalog_client.delete_environment(environment['id'])
self.assertRaises(exceptions.NotFound,
self.application_catalog_client.get_environment,
environment['id'])
def resource_setup(cls):
super(TestEnvironmentTemplatesNegative, cls).resource_setup()
cls.name = utils.generate_name(cls.__name__)
cls.env_template = cls.application_catalog_client.\
create_env_template(cls.name)
cls.environment = cls.application_catalog_client.\
create_environment(cls.name)
cls.alt_client = cls.get_client_with_isolated_creds('alt')
def test_get_deleted_env_template(self):
name = utils.generate_name('get_deleted_env_template')
env_template = self.application_catalog_client.\
create_env_template(name)
self.application_catalog_client.delete_env_template(env_template['id'])
self.assertRaises(exceptions.NotFound,
self.application_catalog_client.get_env_template,
env_template['id'])
def test_get_deleted_env_template(self):
name = utils.generate_name('get_deleted_env_template')
env_template = self.application_catalog_client.\
create_env_template(name)
self.application_catalog_client.delete_env_template(
env_template['id'])
self.assertRaises(exceptions.NotFound,
self.application_catalog_client.get_env_template,
env_template['id'])
def test_get_services_list_after_delete_env(self):
name = utils.generate_name("get_services_list_after_delete_env")
environment = self.application_catalog_client.create_environment(name)
session = self.application_catalog_client.\
create_session(environment['id'])
self.application_catalog_client.delete_environment(environment['id'])
self.assertRaises(exceptions.NotFound,
self.application_catalog_client.get_services_list,
environment['id'], session['id'])
def test_clone_env_template(self):
name = utils.generate_name('clone_env_template')
cloned_template = self.alt_client.\
clone_env_template(self.env_template['id'], name)
self.addCleanup(self.alt_client.delete_env_template,
cloned_template['id'])
self.assertEqual(name, cloned_template['name'])
template = self.alt_client.get_env_template(cloned_template['id'])
self.assertEqual(name, template['name'])
def test_deploy_app_with_volume_creation_from_backup(self):
"""Test app deployment with volume creation from volume backup
Scenario:
1. Make backup from volume
2. Create environment
3. Add ApacheHTTPServer application with ability to create Cinder
volume with size 1 GiB from existing volume backup and attach it to
the instance
4. Deploy environment
5. Make sure that deployment finished successfully
6. Check that application is accessible
7. Check that volume is attached to the instance, has size 1GiB and
restored from existing volume backup
8. Delete environment, backup
"""
if not (CONF.volume_feature_enabled.backup
and CONF.service_available.swift):
msg = ("Cinder backup driver and Swift are required. "
"Deploy app with volume restoring from backup test "
"will be skipped.")
raise self.skipException(msg)
backup = self.create_backup(self.volume)
self.addCleanup(self.delete_backup, backup)
name = utils.generate_name('testMurano')
environment = self.application_catalog_client.\
create_environment(name)
self.addCleanup(self.environment_delete, environment['id'])
session = self.application_catalog_client.\
create_session(environment['id'])
volume_attributes = {
"/dev/vdb": {
"?": {
"type": "io.murano.resources.CinderVolume"
},
"size": 1,
"name": "restore_backup_" + backup,
"sourceVolumeBackup": {
"?": {
"type": "io.murano.resources.CinderVolumeBackup"
},
"openstackId": backup
}
}
}
post_body = self.apache_cinder(volume_attributes)
self.application_catalog_client.\
create_service(environment['id'], session['id'],
post_body)
self.deploy_environment(environment, session)
self.status_check(environment['id'], [['testMurano', 22, 80]])
volume_data = self.get_volume(environment['id'])
self.check_volume_attached('testMurano', volume_data['id'])
self.assertEqual(volume_data['size'], 1)
self.assertIn(backup, volume_data['display_name'])
def test_get_session_after_delete_env(self):
name = utils.generate_name('get_session_after_delete_env')
environment = self.application_catalog_client.create_environment(name)
session = self.application_catalog_client.\
create_session(environment['id'])
self.application_catalog_client.delete_environment(environment['id'])
self.assertRaises(exceptions.NotFound,
self.application_catalog_client.get_session,
environment['id'], session['id'])
def resource_setup(cls):
super(TestRepository, cls).resource_setup()
application_name = utils.generate_name('test_repository_class')
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
def test_clone_env_template(self):
name = utils.generate_name('clone_env_template')
cloned_template = self.alt_client.\
clone_env_template(self.env_template['id'], name)
self.addCleanup(self.alt_client.delete_env_template,
cloned_template['id'])
self.assertEqual(name, cloned_template['name'])
template = self.alt_client.get_env_template(cloned_template['id'])
self.assertEqual(name, template['name'])
def test_create_public_env_template(self):
name = utils.generate_name('create_public_env_template')
env_template = self.application_catalog_client.\
create_public_env_template(name)
self.addCleanup(self.application_catalog_client.delete_env_template,
env_template['id'])
self.assertEqual(name, env_template['name'])
env_temp = self.application_catalog_client.\
get_env_template(env_template['id'])
self.assertTrue(env_temp['is_public'])
def test_create_and_delete_env_template(self):
name = utils.generate_name("create_and_delete_env_template")
env_template = self.application_catalog_client.create_env_template(name)
self.assertFalse(env_template["is_public"])
self.assertEqual(name, env_template["name"])
env_templates_list = self.application_catalog_client.get_env_templates_list()
self.assertIn(env_template, env_templates_list)
self.application_catalog_client.delete_env_template(env_template["id"])
env_templates_list = self.application_catalog_client.get_env_templates_list()
self.assertNotIn(env_template, env_templates_list)
def test_create_public_env_template(self):
name = utils.generate_name('create_public_env_template')
env_template = self.application_catalog_client.\
create_public_env_template(name)
self.addCleanup(self.application_catalog_client.delete_env_template,
env_template['id'])
self.assertEqual(name, env_template['name'])
env_temp = self.application_catalog_client.\
get_env_template(env_template['id'])
self.assertTrue(env_temp['is_public'])
def update_executor(self, flavor='m1.medium'):
post_body = {
"instance": {
"flavor": flavor,
"image": self.linux_image,
"assignFloatingIp": True,
"?": {
"type": "io.murano.resources.LinuxMuranoInstance",
"id": utils.generate_uuid()
},
"name": utils.generate_name('testMurano')
},
"name": utils.generate_name('dummy'),
"?": {
"type": "io.murano.apps.test.UpdateExecutor",
"id": utils.generate_uuid()
}
}
return post_body
def test_create_and_delete_category(self):
name = utils.generate_name('create_and_delete_category')
categories_list = self.application_catalog_client.list_categories()
self.assertNotIn(name, categories_list)
category = self.application_catalog_client.create_category(name)
self.assertEqual(name, category['name'])
categories_list = self.application_catalog_client.list_categories()
self.assertIn(name, categories_list)
self.application_catalog_client.delete_category(category['id'])
categories_list = self.application_catalog_client.list_categories()
self.assertNotIn(name, categories_list)
def test_create_and_delete_category(self):
name = utils.generate_name('create_and_delete_category')
categories_list = self.application_catalog_client.list_categories()
self.assertNotIn(name, categories_list)
category = self.application_catalog_client.create_category(name)
self.assertEqual(name, category['name'])
categories_list = self.application_catalog_client.list_categories()
self.assertIn(name, categories_list)
self.application_catalog_client.delete_category(category['id'])
categories_list = self.application_catalog_client.list_categories()
self.assertNotIn(name, categories_list)
def resource_setup(cls):
super(TestRepositoryNegativeForbidden, cls).resource_setup()
application_name = utils.generate_name('package_test_upload')
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
cls.alt_client = cls.get_client_with_isolated_creds(
type_of_creds='alt')
def resource_setup(cls):
super(TestRepositoryNegativeForbidden, cls).resource_setup()
application_name = utils.generate_name('package_test_upload')
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
cls.alt_client = cls.get_client_with_isolated_creds(
type_of_creds='alt')
def test_create_env_template_with_a_service(self):
name = utils.generate_name('create_env_template_with_service')
post_body = self._get_demo_app()
env_template = self.application_catalog_client.\
create_env_template_with_services(name, post_body)
self.addCleanup(self.application_catalog_client.delete_env_template,
env_template['id'])
list_services = self.application_catalog_client.\
get_services_list_in_env_template(env_template['id'])
self.assertIsInstance(list_services, list)
self.assertIn(post_body, list_services)
def test_create_env_from_template(self):
name = utils.generate_name('create_env_from_template')
env_template = self.application_catalog_client.\
create_public_env_template(name)
self.addCleanup(self.application_catalog_client.delete_env_template,
env_template['id'])
post_body = self._get_demo_app()
service = self.application_catalog_client.\
create_service_in_env_template(env_template['id'], post_body)
self.assertEqual(post_body['name'], service['name'])
env_name = utils.generate_name('create_env_from_template')
environment = self.application_catalog_client.\
create_env_from_template(env_template['id'], env_name)
self.addCleanup(self.application_catalog_client.delete_environment,
environment['environment_id'])
self.assertIsNotNone(environment)
service_from_env = self.application_catalog_client.\
get_service(environment['environment_id'],
service['?']['id'],
environment['session_id'])
self.assertEqual(service, service_from_env)
def resource_setup(cls):
super(TestRepository, cls).resource_setup()
application_name = utils.generate_name('test_repository_class')
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive, {
"categories": [],
"tags": [],
'is_public': False
})
def test_upload_and_delete_package(self):
application_name = utils.generate_name('package_test_upload')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
package_list = self.application_catalog_client.get_list_packages()
self.assertIn(package['id'], {pkg['id'] for pkg in package_list})
self.application_catalog_client.delete_package(package['id'])
package_list = self.application_catalog_client.get_list_packages()
self.assertNotIn(package['id'], {pkg['id'] for pkg in package_list})
def test_create_and_delete_env_template(self):
name = utils.generate_name('create_and_delete_env_template')
env_template = self.application_catalog_client.\
create_env_template(name)
self.assertFalse(env_template['is_public'])
self.assertEqual(name, env_template['name'])
env_templates_list = self.application_catalog_client.\
get_env_templates_list()
self.assertIn(env_template, env_templates_list)
self.application_catalog_client.\
delete_env_template(env_template['id'])
env_templates_list = self.application_catalog_client.\
get_env_templates_list()
self.assertNotIn(env_template, env_templates_list)
def resource_setup(cls):
if CONF.application_catalog.glare_backend:
msg = ("Murano using GLARE backend. "
"Repository tests will be skipped.")
raise cls.skipException(msg)
super(TestRepository, cls).resource_setup()
application_name = utils.generate_name('test_repository_class')
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
cls.package = cls.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
def resource_setup(cls):
super(TestStaticActions, cls).resource_setup()
application_name = utils.generate_name('test_repository_class')
cls.abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name, add_class_name=True)
if CONF.application_catalog.glare_backend:
client = cls.artifacts_client
else:
client = cls.application_catalog_client
cls.package = client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
def test_create_and_delete_environment(self):
environments_list = self.application_catalog_client.\
get_environments_list()
name = utils.generate_name('create_and_delete_env')
environment = self.application_catalog_client.create_environment(name)
self.assertEqual(name, environment['name'])
upd_environments_list = self.application_catalog_client.\
get_environments_list()
self.assertEqual(len(environments_list) + 1,
len(upd_environments_list))
self.application_catalog_client.delete_environment(environment['id'])
upd_environments_list = self.application_catalog_client.\
get_environments_list()
self.assertEqual(len(environments_list),
len(upd_environments_list))
def test_upload_and_delete_package(self):
application_name = utils.generate_name('package_test_upload')
abs_archive_path, dir_with_archive, archive_name = \
utils.prepare_package(application_name)
self.addCleanup(os.remove, abs_archive_path)
packages_list = self.application_catalog_client.get_list_packages()
package = self.application_catalog_client.upload_package(
application_name, archive_name, dir_with_archive,
{"categories": [], "tags": [], 'is_public': False})
updated_packages_list = self.application_catalog_client.\
get_list_packages()
self.assertEqual(len(packages_list) + 1, len(updated_packages_list))
self.application_catalog_client.delete_package(package['id'])
updated_packages_list = self.application_catalog_client.\
get_list_packages()
self.assertEqual(len(packages_list), len(updated_packages_list))
def resource_setup(cls):
super(TestEnvTemplatesTenantIsolation, cls).resource_setup()
name = utils.generate_name(cls.__name__)
cls.env_template = cls.application_catalog_client.\
create_env_template(name)
cls.alt_client = cls.get_client_with_isolated_creds('alt')
def resource_setup(cls):
super(TestServicesNegative, cls).resource_setup()
name = utils.generate_name(cls.__name__)
cls.environment = cls.application_catalog_client.\
create_environment(name)
def resource_setup(cls):
super(TestEnvironmentTemplates, cls).resource_setup()
name = utils.generate_name(cls.__name__)
cls.env_template = cls.application_catalog_client.create_public_env_template(name)
cls.alt_client = cls.get_client_with_isolated_creds("alt")
