def test_cloud_instance_discovery(request, provider_crud, provider_init, provider_mgmt, instance_name): """ Tests whether cfme will successfully discover a cloud instance change (add/delete). As there is currently no way to listen to AWS events, CFME must be refreshed manually to see the changes. Metadata: test_flag: discovery """ if not provider_mgmt.does_vm_exist(instance_name): deploy_template(provider_crud.key, instance_name, allow_skip="default") test_instance = instance.instance_factory(instance_name, provider_crud) request.addfinalizer(test_instance.delete_from_provider) try: wait_for(_does_instance_exist_in_CFME, [test_instance], num_sec=800, delay=30, fail_func=test_instance.provider_crud.refresh_provider_relationships, handle_exception=True) except TimedOutError: pytest.fail("Instance was not found in CFME") test_instance.delete_from_provider() try: wait_for(_is_instance_archived, [test_instance], num_sec=800, delay=30, fail_func=test_instance.provider_crud.refresh_provider_relationships, handle_exception=True) except TimedOutError: pytest.fail("instance was not found in Archives")
def test_provision_from_template(request, setup_provider, provider, provisioning, vm_name): """ Tests instance provision from template Metadata: test_flag: provision """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) instance = instance_factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args)
def test_provision_from_template(request, setup_provider, provider_crud, provisioning, vm_name): """ Tests instance provision from template Metadata: test_flag: provision """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider_crud, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args)
def test_provision_from_template(request, setup_provider, provider_crud, provisioning, vm_name): """ Tests instance provision from template Metadata: test_flag: provision """ image = provisioning["image"]["name"] note = "Testing provisioning from image %s to vm %s on provider %s" % (image, vm_name, provider_crud.key) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { "email": "*****@*****.**", "first_name": "Image", "last_name": "Provisioner", "notes": note, "instance_type": provisioning["instance_type"], "availability_zone": provisioning["availability_zone"], "security_groups": [provisioning["security_group"]], "guest_keypair": provisioning["guest_keypair"], } if isinstance(provider_crud, OpenStackProvider): inst_args["cloud_network"] = provisioning["cloud_network"] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args)
def test_instance(setup_provider, request, delete_instances_fin, provider, vm_name): """ Fixture to provision instance on the provider """ instance = instance_factory(vm_name, provider) if not provider.mgmt.does_vm_exist(vm_name): delete_instances_fin[provider.key] = instance instance.create_on_provider(allow_skip="default") return instance
def test_instance(setup_provider, request, delete_instances_fin, provider_crud, provider_mgmt, vm_name): """ Fixture to provision instance on the provider """ instance = instance_factory(vm_name, provider_crud) if not provider_mgmt.does_vm_exist(vm_name): delete_instances_fin[provider_crud.key] = instance instance.create_on_provider(allow_skip="default") return instance
def test_delete_instance(setup_provider, provider, remove_test): """ Tests delete instance Metadata: test_flag: delete_object """ instance_name = remove_test['instance'] test_instance = instance.instance_factory(instance_name, provider) test_instance.remove_from_cfme(cancel=False) test_instance.wait_for_delete() provider.refresh_provider_relationships() test_instance.wait_for_vm_to_appear()
def test_delete_instance(setup_provider, provider_crud, remove_test): """ Tests delete instance Metadata: test_flag: delete_object """ instance_name = remove_test['instance'] test_instance = instance.instance_factory(instance_name, provider_crud) test_instance.remove_from_cfme(cancel=False) test_instance.wait_for_delete() provider_crud.refresh_provider_relationships() test_instance.wait_for_vm_to_appear()
def test_provision_cloud_init(request, setup_provider, provider, provisioning, setup_ci_template, vm_name): """ Tests provisioning from a template with cloud_init Metadata: test_flag: cloud_init, provision """ image = provisioning.get('ci-image', None) or provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) mgmt_system = provider.mgmt instance = instance_factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'], 'custom_template': { 'name': [provisioning['ci-template']] }, } if isinstance(provider, OpenStackProvider): floating_ip = mgmt_system.get_first_floating_ip() inst_args['cloud_network'] = provisioning['cloud_network'] inst_args['public_ip_address'] = floating_ip sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300, handle_exception=True) # Check that we can at least get the uptime via ssh this should only be possible # if the username and password have been set via the cloud-init script so # is a valid check sshclient = ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'], password=provisioning['ci-pass']) wait_for(sshclient.uptime, num_sec=200, handle_exception=True)
def test_instance(request, delete_instances_fin, setup_provider, provider, vm_name): """ Fixture to provision instance on the provider """ instance = instance_factory(vm_name, provider) if not provider.mgmt.does_vm_exist(vm_name): delete_instances_fin[provider.key] = instance instance.create_on_provider(allow_skip="default") elif isinstance(instance, EC2Instance) and \ provider.mgmt.is_vm_state(vm_name, provider.mgmt.states['deleted']): provider.mgmt.set_name( vm_name, 'test_terminated_{}'.format(fauxfactory.gen_alphanumeric(8))) delete_instances_fin[provider.key] = instance instance.create_on_provider(allow_skip="default") return instance
def test_provision_cloud_init(request, setup_provider, provider_crud, provisioning, setup_ci_template, vm_name): """ Tests provisioning from a template with cloud_init Metadata: test_flag: cloud_init, provision """ image = provisioning.get('ci-image', None) or provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) mgmt_system = provider_crud.get_mgmt_system() instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'], 'custom_template': {'name': [provisioning['ci-template']]}, } if isinstance(provider_crud, OpenStackProvider): floating_ip = mgmt_system.get_first_floating_ip() inst_args['cloud_network'] = provisioning['cloud_network'] inst_args['public_ip_address'] = floating_ip sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) connect_ip, tc = wait_for(mgmt_system.get_ip_address, [vm_name], num_sec=300, handle_exception=True) # Check that we can at least get the uptime via ssh this should only be possible # if the username and password have been set via the cloud-init script so # is a valid check sshclient = ssh.SSHClient(hostname=connect_ip, username=provisioning['ci-username'], password=provisioning['ci-pass']) wait_for(sshclient.uptime, num_sec=200, handle_exception=True)
def test_provision_from_template(request, setup_providers, provider_crud, provisioning, vm_name): image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) instance.create( email='*****@*****.**', first_name='Image', last_name='Provisioner', notes=note, instance_type=provisioning['instance_type'], availability_zone=provisioning['availability_zone'], security_groups=[provisioning['security_group']], guest_keypair=provisioning['guest_keypair'] )
def test_provision_from_template_with_attached_disks( request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, disks, soft_assert, provider_type, domain, cls, ): """ Tests provisioning from a template and attaching disks Metadata: test_flag: provision """ image = provisioning["image"]["name"] note = "Testing provisioning from image %s to vm %s on provider %s" % (image, vm_name, provider_crud.key) DEVICE_NAME = "/dev/sd{}" device_mapping = [] with provider_mgmt.with_volumes(1, n=disks) as volumes: for i, volume in enumerate(volumes): device_mapping.append((volume, DEVICE_NAME.format(chr(ord("b") + i)))) # Set up automate method = automate.Method(name="openstack_PreProvision", cls=cls) with update(method): disk_mapping = [] for mapping in device_mapping: disk_mapping.append(ONE_FIELD % mapping) method.data = VOLUME_METHOD % ", ".join(disk_mapping) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { "email": "*****@*****.**", "first_name": "Image", "last_name": "Provisioner", "notes": note, "instance_type": provisioning["instance_type"], "availability_zone": provisioning["availability_zone"], "security_groups": [provisioning["security_group"]], "guest_keypair": provisioning["guest_keypair"], } if isinstance(provider_crud, OpenStackProvider): inst_args["cloud_network"] = provisioning["cloud_network"] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) for volume_id in volumes: soft_assert(vm_name in provider_mgmt.volume_attachments(volume_id)) for volume, device in device_mapping: soft_assert(provider_mgmt.volume_attachments(volume)[vm_name] == device) instance.delete_from_provider() # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_with_additional_volume(request, setup_provider, provisioning, provider, vm_name, soft_assert, copy_domains, domain): """ Tests provisioning with setting specific image from AE and then also making it create and attach an additional 3G volume. Metadata: test_flag: provision, volumes """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) # Set up automate cls = automate.Class(name="Methods", namespace=automate.Namespace.make_path( "Cloud", "VM", "Provisioning", "StateMachines", parent=domain)) method = automate.Method(name="openstack_CustomizeRequest", cls=cls) try: image_id = provider.mgmt.get_template_id( provider.data["small_template"]) except KeyError: pytest.skip("No small_template in provider adta!") with update(method): method.data = dedent('''\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "image", :destination_type => "volume", :volume_size => 3, :delete_on_termination => false }] } ) ''' % (image_id, )) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) prov_instance = provider.mgmt._find_instance_by_name(vm_name) try: assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached') volumes_attached = getattr(prov_instance, 'os-extended-volumes:volumes_attached') assert len(volumes_attached) == 1 volume_id = volumes_attached[0]["id"] assert provider.mgmt.volume_exists(volume_id) volume = provider.mgmt.get_volume(volume_id) assert volume.size == 3 finally: instance.delete_from_provider() wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5) if "volume_id" in locals(): # To handle the case of 1st or 2nd assert if provider.mgmt.volume_exists(volume_id): provider.mgmt.delete_volume(volume_id)
def test_provision_with_additional_volume( request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, soft_assert, provider_type, default_domain_enabled, provider_data): """ Tests provisioning with setting specific image from AE and then also making it create and attach an additional 3G volume. Metadata: test_flag: provision, volumes """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) # Set up automate cls = automate.Class( name="Methods", namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines")) method = automate.Method( name="openstack_CustomizeRequest", cls=cls) try: image_id = provider_mgmt.get_template_id(provider_data["small_template"]) except KeyError: pytest.skip("No small_template in provider adta!") with update(method): method.data = dedent('''\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "image", :destination_type => "volume", :volume_size => 3, :delete_on_termination => false }] } ) ''' % (image_id, )) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider_crud, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) prov_instance = provider_mgmt._find_instance_by_name(vm_name) try: assert hasattr(prov_instance, 'os-extended-volumes:volumes_attached') volumes_attached = getattr(prov_instance, 'os-extended-volumes:volumes_attached') assert len(volumes_attached) == 1 volume_id = volumes_attached[0]["id"] assert provider_mgmt.volume_exists(volume_id) volume = provider_mgmt.get_volume(volume_id) assert volume.size == 3 finally: instance.delete_from_provider() wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5) if volume_id in locals(): if provider_mgmt.volume_exists(volume_id): provider_mgmt.delete_volume(volume_id)
def test_provision_with_boot_volume( request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, soft_assert, provider_type, default_domain_enabled): """ Tests provisioning from a template and attaching one booting volume. Metadata: test_flag: provision, volumes """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) with provider_mgmt.with_volume(1) as volume: # Set up automate cls = automate.Class( name="Methods", namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines")) method = automate.Method( name="openstack_CustomizeRequest", cls=cls) with update(method): method.data = dedent('''\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "volume", :destination_type => "volume", :delete_on_termination => false }] } ) ''' % (volume, )) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider_crud, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) soft_assert(vm_name in provider_mgmt.volume_attachments(volume)) soft_assert(provider_mgmt.volume_attachments(volume)[vm_name] == "vda") instance.delete_from_provider() # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_from_template_with_attached_disks( request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, disks, soft_assert, provider_type, default_domain_enabled): """ Tests provisioning from a template and attaching disks Metadata: test_flag: provision """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider_crud.key)) DEVICE_NAME = "/dev/sd{}" device_mapping = [] with provider_mgmt.with_volumes(1, n=disks) as volumes: for i, volume in enumerate(volumes): device_mapping.append((volume, DEVICE_NAME.format(chr(ord("b") + i)))) # Set up automate cls = automate.Class( name="Methods", namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines")) method = automate.Method( name="openstack_PreProvision", cls=cls) with update(method): disk_mapping = [] for mapping in device_mapping: disk_mapping.append(ONE_FIELD % mapping) method.data = VOLUME_METHOD % ", ".join(disk_mapping) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider_crud, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) for volume_id in volumes: soft_assert(vm_name in provider_mgmt.volume_attachments(volume_id)) for volume, device in device_mapping: soft_assert(provider_mgmt.volume_attachments(volume)[vm_name] == device) instance.delete_from_provider() # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_with_boot_volume(request, setup_provider, provider, provisioning, vm_name, soft_assert, domain, copy_domains): """ Tests provisioning from a template and attaching one booting volume. Metadata: test_flag: provision, volumes """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) with provider.mgmt.with_volume( 1, imageRef=provider.mgmt.get_template_id(image)) as volume: # Set up automate cls = automate.Class(name="Methods", namespace=automate.Namespace.make_path( "Cloud", "VM", "Provisioning", "StateMachines", parent=domain)) method = automate.Method(name="openstack_CustomizeRequest", cls=cls) with update(method): method.data = dedent('''\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "volume", :destination_type => "volume", :delete_on_termination => false }] } ) ''' % (volume, )) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) soft_assert(vm_name in provider.mgmt.volume_attachments(volume)) soft_assert(provider.mgmt.volume_attachments(volume)[vm_name] == "vda") instance.delete_from_provider( ) # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_with_boot_volume( request, setup_provider, provider_crud, provisioning, vm_name, provider_mgmt, soft_assert, provider_type ): """ Tests provisioning from a template and attaching one booting volume. Metadata: test_flag: provision, volumes """ image = provisioning["image"]["name"] note = "Testing provisioning from image %s to vm %s on provider %s" % (image, vm_name, provider_crud.key) with provider_mgmt.with_volume(1, imageRef=provider_mgmt.get_template_id(image)) as volume: # Set up automate cls = automate.Class( name="Methods", namespace=automate.Namespace.make_path("Cloud", "VM", "Provisioning", "StateMachines") ) method = automate.Method(name="openstack_CustomizeRequest", cls=cls) with update(method): method.data = dedent( """\ $evm.root["miq_provision"].set_option( :clone_options, { :image_ref => nil, :block_device_mapping_v2 => [{ :boot_index => 0, :uuid => "%s", :device_name => "vda", :source_type => "volume", :destination_type => "volume", :delete_on_termination => false }] } ) """ % (volume,) ) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider_crud, image) request.addfinalizer(instance.delete_from_provider) inst_args = { "email": "*****@*****.**", "first_name": "Image", "last_name": "Provisioner", "notes": note, "instance_type": provisioning["instance_type"], "availability_zone": provisioning["availability_zone"], "security_groups": [provisioning["security_group"]], "guest_keypair": provisioning["guest_keypair"], } if isinstance(provider_crud, OpenStackProvider): inst_args["cloud_network"] = provisioning["cloud_network"] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) soft_assert(vm_name in provider_mgmt.volume_attachments(volume)) soft_assert(provider_mgmt.volume_attachments(volume)[vm_name] == "vda") instance.delete_from_provider() # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)
def test_provision_from_template_with_attached_disks(request, setup_provider, provider, provisioning, vm_name, disks, soft_assert, domain, cls, copy_domains): """ Tests provisioning from a template and attaching disks Metadata: test_flag: provision """ image = provisioning['image']['name'] note = ('Testing provisioning from image %s to vm %s on provider %s' % (image, vm_name, provider.key)) DEVICE_NAME = "/dev/sd{}" device_mapping = [] with provider.mgmt.with_volumes(1, n=disks) as volumes: for i, volume in enumerate(volumes): device_mapping.append( (volume, DEVICE_NAME.format(chr(ord("b") + i)))) # Set up automate cls = automate.Class(name="Methods", namespace=automate.Namespace.make_path( "Cloud", "VM", "Provisioning", "StateMachines", parent=domain)) method = automate.Method(name="openstack_PreProvision", cls=cls) with update(method): disk_mapping = [] for mapping in device_mapping: disk_mapping.append(ONE_FIELD % mapping) method.data = VOLUME_METHOD % ", ".join(disk_mapping) def _finish_method(): with update(method): method.data = """prov = $evm.root["miq_provision"]""" request.addfinalizer(_finish_method) instance = instance_factory(vm_name, provider, image) request.addfinalizer(instance.delete_from_provider) inst_args = { 'email': '*****@*****.**', 'first_name': 'Image', 'last_name': 'Provisioner', 'notes': note, 'instance_type': provisioning['instance_type'], 'availability_zone': provisioning['availability_zone'], 'security_groups': [provisioning['security_group']], 'guest_keypair': provisioning['guest_keypair'] } if isinstance(provider, OpenStackProvider): inst_args['cloud_network'] = provisioning['cloud_network'] sel.force_navigate("clouds_instances_by_provider") instance.create(**inst_args) for volume_id in volumes: soft_assert(vm_name in provider.mgmt.volume_attachments(volume_id)) for volume, device in device_mapping: soft_assert( provider.mgmt.volume_attachments(volume)[vm_name] == device) instance.delete_from_provider( ) # To make it possible to delete the volume wait_for(lambda: not instance.does_vm_exist_on_provider(), num_sec=180, delay=5)