def _create_volume(volume_name, volume_type='', *args, **kwargs):
volumes_steps_ui.create_volume(volume_name,
volume_type=volume_type,
*args,
**kwargs)
volume = utils.AttrDict(name=volume_name)
volumes.append(volume)
return volume
def _import_keypair(public_key):
name = next(utils.generate_ids('keypair'))
keypairs_steps.import_keypair(name, public_key)
keypair = utils.AttrDict(name=name)
keypairs.append(keypair)
return keypair
def keypair(keypairs_steps):
"""Create keypair."""
name = next(utils.generate_ids('keypair'))
keypairs_steps.create_keypair(name)
_keypair = utils.AttrDict(name=name)
yield _keypair
keypairs_steps.delete_keypair(_keypair.name)
def _create_host_aggregates(*host_aggregate_names):
_host_aggregates = []
for host_aggregate_name in host_aggregate_names:
host_aggregates_steps.create_host_aggregate(host_aggregate_name)
host_aggregate = utils.AttrDict(name=host_aggregate_name)
host_aggregates.append(host_aggregate)
_host_aggregates.append(host_aggregate)
return _host_aggregates
def instance(instances_steps):
"""Create instance."""
instance_name = next(utils.generate_ids('instance'))
instances_steps.create_instance(
instance_name, network_name=config.INTERNAL_NETWORK_NAME)
instance = utils.AttrDict(name=instance_name)
yield instance
instances_steps.delete_instance(instance.name)
def _create_flavors(*flavor_names):
_flavors = []
for flavor_name in flavor_names:
flavors_steps.create_flavor(flavor_name)
flavor = utils.AttrDict(name=flavor_name)
flavors.append(flavor)
_flavors.append(flavor)
return _flavors
def _create_users(usernames):
_users = []
for username in usernames:
users_steps.create_user(username, username, config.USER_PROJECT)
user = utils.AttrDict(name=username, password=username)
users.append(user)
_users.append(user)
return _users
def _create_networks(network_names):
_networks = []
for network_name in network_names:
networks_steps.create_network(network_name)
network = utils.AttrDict(name=network_name)
networks.append(network)
_networks.append(network)
return _networks
def _create_backups(backup_names, *args, **kwargs):
_backups = []
for backup_name in backup_names:
volumes_steps_ui.create_backup(volume.name, backup_name, *args,
**kwargs)
backup = utils.AttrDict(name=backup_name)
backups.append(backup)
_backups.append(backup)
return _backups
def _create_instance(instance_name,
network_name=config.INTERNAL_NETWORK_NAME,
count=1):
_instances = []
instance_names = instances_steps.create_instance(
instance_name, network_name=network_name, count=count)
for name in instance_names:
instance = utils.AttrDict(name=name)
instances.append(instance)
_instances.append(instance)
return _instances
def qos_spec(volume_types_steps):
"""Create QoS Spec.
Arguments:
- volume_types_steps: in order to create QoS Spec.
"""
name = next(utils.generate_ids('qos-spec'))
volume_types_steps.create_qos_spec(name)
_qos_spec = utils.AttrDict(name=name)
yield _qos_spec
volume_types_steps.delete_qos_spec(_qos_spec.name)
def volume_type(volume_types_steps):
"""Create volume type.
Arguments:
- volume_types_steps: in order to create volume type.
"""
name = next(utils.generate_ids('volume-type'))
volume_types_steps.create_volume_type(name)
_volume_type = utils.AttrDict(name=name)
yield _volume_type
volume_types_steps.delete_volume_type(_volume_type.name)
def _create_images(*image_names):
_images = []
for image_name in image_names:
images_steps.create_image(image_name, check=False)
images_steps.close_notification('success')
image = utils.AttrDict(name=image_name)
images.append(image)
_images.append(image)
for image_name in image_names:
horizon.page_images.table_images.row(
name=image_name).wait_for_status('Active')
return _images
def _create_volumes(volume_names):
_volumes = []
for volume_name in volume_names:
volumes_steps_ui.create_volume(volume_name, check=False)
volumes_steps_ui.close_notification('info')
volume = utils.AttrDict(name=volume_name)
volumes.append(volume)
_volumes.append(volume)
tab_volumes = volumes_steps_ui._tab_volumes()
for volume_name in volume_names:
tab_volumes.table_volumes.row(
name=volume_name).wait_for_status('Available')
return _volumes
def _create_snapshots(snapshot_names):
_snapshots = []
for snapshot_name in snapshot_names:
volumes_steps_ui.create_snapshot(volume.name,
snapshot_name,
check=False)
volumes_steps_ui.close_notification('info')
snapshot = utils.AttrDict(name=snapshot_name)
snapshots.append(snapshot)
_snapshots.append(snapshot)
tab_snapshots = volumes_steps_ui._tab_snapshots()
for snapshot_name in snapshot_names:
tab_snapshots.table_snapshots.row(
name=snapshot_name).wait_for_status('Available',
config.EVENT_TIMEOUT)
return _snapshots
def images(request, get_glance_steps, uncleanable, credentials):
"""Fixture to create cirros images with default options.
Args:
request (obj): py.test's SubRequest instance
get_glance_steps (function): function to get glance steps
uncleanable (AttrDict): data structure with skipped resources
credentials (object): CredentialsManager instance
Returns:
list: AttrDict instances with created images' names
"""
params = {'count': 1}
params.update(getattr(request, 'param', {}))
names = utils.generate_ids('cirros', count=params['count'])
with create_images_context(get_glance_steps,
uncleanable,
credentials,
names,
config.CIRROS_QCOW2_URL) as images:
yield [utils.AttrDict(name=image['name']) for image in images]
def _create_project(project_name):
projects_steps.create_project(project_name)
project = utils.AttrDict(name=project_name)
projects.append(project)
return project
def _create_security_group(group_name):
access_steps.create_security_group(group_name)
security_group = utils.AttrDict(name=group_name)
security_groups.append(security_group)
return security_group
def _allocate_floating_ip():
ip = floating_ips_steps_ui.allocate_floating_ip()
floating_ip = utils.AttrDict(ip=ip)
floating_ips.append(floating_ip)
return floating_ip
def _create_network(network_name, shared=False):
networks_steps.create_network(network_name, shared=shared)
network = utils.AttrDict(name=network_name)
networks.append(network)
return network
def _create_user(username, password, project):
users_steps.create_user(username, password, project)
user = utils.AttrDict(name=username, password=password)
users.append(user)
return user
def _create_container(container_name, public=False):
containers_steps_ui.create_container(container_name, public=public)
container = utils.AttrDict(name=container_name)
containers.append(container)
return container
def _create_image(image_name, *args, **kwgs):
images_steps.create_image(image_name, *args, **kwgs)
image = utils.AttrDict(name=image_name)
images.append(image)
return image
def _create_namespace(namespace_name):
namespaces_steps.create_namespace(namespace_name)
namespace = utils.AttrDict(name=namespace_name)
namespaces.append(namespace)
return namespace
def _create_flavor(flavor_name):
flavors_steps.create_flavor(flavor_name)
flavor = utils.AttrDict(name=flavor_name)
flavors.append(flavor)
return flavor
def _create_host_aggregate(host_aggregate_name):
host_aggregates_steps.create_host_aggregate(host_aggregate_name)
host_aggregate = utils.AttrDict(name=host_aggregate_name)
host_aggregates.append(host_aggregate)
return host_aggregate
def _create_router(router_name):
routers_steps.create_router(router_name)
router = utils.AttrDict(name=router_name)
routers.append(router)
return router
def _create_snapshot(snapshot_name, *args, **kwargs):
volumes_steps_ui.create_snapshot(volume.name, snapshot_name, *args,
**kwargs)
snapshot = utils.AttrDict(name=snapshot_name)
snapshots.append(snapshot)
return snapshot
