def test_scope_windows_registry_stuck(request, appliance, infra_provider,
policy_collection,
policy_profile_collection):
"""If you provide Scope checking windows registry, it messes CFME up. Recoverable."""
policy = policy_collection.create(
VMCompliancePolicy,
"Windows registry scope glitch testing Compliance Policy",
active=True,
scope=
r"fill_registry(HKLM\SOFTWARE\Microsoft\CurrentVersion\Uninstall\test, "
r"some value, INCLUDES, some content)")
request.addfinalizer(lambda: policy.delete() if policy.exists else None)
profile = policy_profile_collection.create(
"Windows registry scope glitch testing Compliance Policy",
policies=[policy])
request.addfinalizer(lambda: profile.delete() if profile.exists else None)
# Now assign this malformed profile to a VM
vm = VM.factory(
InfraVm.get_first_vm(provider=infra_provider).name, infra_provider)
vm.assign_policy_profiles(profile.description)
# It should be screwed here, but do additional check
navigate_to(appliance.server, 'Dashboard')
view = navigate_to(InfraVm, 'All')
assert "except" not in view.entities.title.text.lower()
vm.unassign_policy_profiles(profile.description)
def new_snapshot(test_vm, has_name=True, memory=False, create_description=True):
name = fauxfactory.gen_alphanumeric(8)
return InfraVm.Snapshot(
name="snpshot_{}".format(name) if has_name else None,
description="snapshot_{}".format(name) if create_description else None,
memory=memory,
parent_vm=test_vm
)
def test_create_snapshot_via_ae(appliance, request, domain, small_test_vm):
"""This test checks whether the vm.create_snapshot works in AE.
Prerequisities:
* A VMware provider
* A VM that has been discovered by CFME
Steps:
* Clone the Request class inside the System namespace into a new domain
* Add a method named ``snapshot`` and insert the provided code there.
* Add an instance named ``snapshot`` and set the methd from previous step
as ``meth5``
* Run the simulation of the method against the VM, preferably setting
``snap_name`` to something that can be checked
* Wait until snapshot with such name appears.
"""
# PREPARE
file = data_path.join("ui").join("automate").join(
"test_create_snapshot_via_ae.rb")
with file.open("r") as f:
method_contents = f.read()
miq_domain = DomainCollection(appliance).instantiate(name='ManageIQ')
miq_class = miq_domain.namespaces.instantiate(
name='System').classes.instantiate(name='Request')
miq_class.copy_to(domain)
request_cls = domain.namespaces.instantiate(
name='System').classes.instantiate(name='Request')
request.addfinalizer(request_cls.delete)
method = request_cls.methods.create(name="snapshot",
location='inline',
script=method_contents)
request.addfinalizer(method.delete)
instance = request_cls.instances.create(
name="snapshot", fields={"meth5": {
'value': "snapshot"
}})
request.addfinalizer(instance.delete)
# SIMULATE
snap_name = fauxfactory.gen_alpha()
snapshot = InfraVm.Snapshot(name=snap_name, parent_vm=small_test_vm)
simulate(appliance=appliance,
instance="Request",
request="snapshot",
target_type='VM and Instance',
target_object=small_test_vm.name,
execute_methods=True,
attributes_values={"snap_name": snap_name})
wait_for(lambda: snapshot.exists,
timeout="2m",
delay=10,
fail_func=small_test_vm.provider.browser.refresh,
handle_exception=True,
message="Waiting for snapshot create")
# Clean up if it appeared
snapshot.delete()
def ssa_vm(request, local_setup_provider, provider, vm_analysis_provisioning_data,
appliance, analysis_type):
""" Fixture to provision instance on the provider """
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type)
vm = VM.factory(vm_name, provider, template_name=vm_analysis_provisioning_data.image)
request.addfinalizer(lambda: vm.cleanup_on_provider())
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
vm.create_on_provider(find_in_cfme=True, **provision_data)
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.provider.mgmt.assign_floating_ip(vm.name, public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
@wait_for_decorator(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, provider.mgmt.vm_status(vm_name), provider.mgmt.is_vm_stopped(vm_name)))
if provider.mgmt.is_vm_stopped(vm_name):
provider.mgmt.start_vm(vm_name)
ip = provider.mgmt.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = provider.mgmt.get_ip_address(vm_name)
assert connect_ip is not None
# 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
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip, username=vm_analysis_provisioning_data['username'],
password=vm_analysis_provisioning_data['password'], port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = InfraVm.CfmeRelationship(vm)
cfme_rel.set_relationship(appliance.server.name, appliance.server_id())
yield vm
# Close the SSH client if we have one
if getattr(vm, 'ssh', None):
vm.ssh.close()
def new_vm(provider, request):
if provider.one_of(CloudProvider):
vm = Instance.factory(random_vm_name(context='cockpit'), provider)
else:
vm = InfraVm.factory(random_vm_name(context='cockpit'), provider)
if not provider.mgmt.does_vm_exist(vm.name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.cleanup_on_provider)
return vm
def new_vm(provider, request):
if provider.one_of(CloudProvider):
vm = Instance.factory(random_vm_name(context='cockpit'), provider)
else:
vm = InfraVm.factory(random_vm_name(context='cockpit'), provider)
if not provider.mgmt.does_vm_exist(vm.name):
vm.create_on_provider(find_in_cfme=True, allow_skip="default")
request.addfinalizer(vm.cleanup_on_provider)
return vm
def test_vm_reconfig_resize_disk_snapshot(request,
disk_type,
disk_mode,
full_vm,
memory=False):
"""
Bugzilla:
1631448
Polarion:
assignee: nansari
initialEstimate: 1/8h
startsin: 5.11
casecomponent: Infra
caseposneg: negative
setup:
1. Have a VM running on vsphere provider
testSteps:
1. Go to Compute -> infrastructure -> Virtual Machines -> Select Vm
2. Create a snapshot for selected VM
3. Go to VM reconfiguration and try to resize disk of the VM
expectedResults:
1. VM selected
2. Snapshot created
3. Resize is not allowed when snapshots are attached
"""
snapshot = InfraVm.Snapshot(
name=fauxfactory.gen_alphanumeric(start="snap_"),
description=fauxfactory.gen_alphanumeric(start="desc_"),
memory=memory,
parent_vm=full_vm)
snapshot.create()
request.addfinalizer(snapshot.delete)
view = navigate_to(full_vm, 'Reconfigure')
row = next(r for r in view.disks_table.rows())
# Delete button should enabled
assert row.actions.widget.is_enabled
# Re-sized button should not displayed
assert not row[9].widget.is_displayed
def test_edit_management_relationship(appliance, new_vm):
"""
check that Edit Management Relationship works for the VM
Bugzilla:
1534400
Polarion:
assignee: jhenner
casecomponent: WebUI
caseimportance: high
initialEstimate: 1/6h
"""
vm_relationship = InfraVm.CfmeRelationship(new_vm)
for i in range(2): # do it 2 times and leave the vm w/o relationship
# set relationship
vm_relationship.set_relationship(appliance.server.name,
appliance.server.sid)
# unset relationship
vm_relationship.remove_relationship()
def do_vm_provisioning(appliance, template_name, provider, vm_name, provisioning_data, request,
smtp_test, num_sec=1500, wait=True):
# generate_tests makes sure these have values
vm = InfraVm(name=vm_name, provider=provider, template_name=template_name)
note = ('template {} to vm {} on provider {}'.format(template_name, vm_name, provider.key))
provisioning_data.update({
'request': {
'email': '*****@*****.**',
'first_name': 'Template',
'last_name': 'Provisioner',
'notes': note}})
view = navigate_to(vm, 'Provision')
view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
view.flash.assert_no_error()
if not wait:
return
# Provision Re important in this test
logger.info('Waiting for cfme provision request for vm %s', vm_name)
request_description = 'Provision from [{}] to [{}]'.format(template_name, vm_name)
provision_request = appliance.collections.requests.instantiate(request_description)
provision_request.wait_for_request(method='ui', num_sec=num_sec)
assert provision_request.is_succeeded(method='ui'), \
"Provisioning failed with the message {}".format(provision_request.row.last_message.text)
# Wait for the VM to appear on the provider backend before proceeding to ensure proper cleanup
logger.info('Waiting for vm %s to appear on provider %s', vm_name, provider.key)
wait_for(provider.mgmt.does_vm_exist, [vm_name], handle_exception=True, num_sec=600)
if smtp_test:
# Wait for e-mails to appear
def verify():
approval = dict(subject_like="%%Your Virtual Machine configuration was Approved%%")
expected_text = "Your virtual machine request has Completed - VM:%%{}".format(vm_name)
return (
len(smtp_test.get_emails(**approval)) > 0 and
len(smtp_test.get_emails(subject_like=expected_text)) > 0
)
wait_for(verify, message="email receive check", delay=30)
def _provisioner(template, provisioning_data, delayed=None):
vm = InfraVm(name=vm_name, provider=provider, template_name=template)
view = navigate_to(vm, 'Provision')
view.form.fill_with(provisioning_data,
on_change=view.form.submit_button)
base_view = vm.appliance.browser.create_view(BaseLoggedInPage)
base_view.flash.assert_no_error()
request.addfinalizer(
lambda: VM.factory(vm_name, provider).cleanup_on_provider())
request_description = 'Provision from [{}] to [{}]'.format(
template, vm_name)
provision_request = appliance.collections.requests.instantiate(
description=request_description)
if delayed is not None:
total_seconds = (delayed - datetime.utcnow()).total_seconds()
try:
wait_for(provision_request.is_finished,
fail_func=provision_request.update,
num_sec=total_seconds,
delay=5)
pytest.fail("The provisioning was not postponed")
except TimedOutError:
pass
logger.info('Waiting for vm %s to appear on provider %s', vm_name,
provider.key)
wait_for(provider.mgmt.does_vm_exist, [vm_name],
fail_func=provider.refresh_provider_relationships,
handle_exception=True,
num_sec=600)
# nav to requests page happens on successful provision
logger.info('Waiting for cfme provision request for vm %s', vm_name)
provision_request.wait_for_request()
msg = "Provisioning failed with the message {}".format(
provision_request.rest.message)
assert provision_request.is_succeeded(), msg
return vm
def test_scope_windows_registry_stuck(request, appliance, infra_provider, policy_collection,
policy_profile_collection):
"""If you provide Scope checking windows registry, it messes CFME up. Recoverable."""
policy = policy_collection.create(
VMCompliancePolicy,
"Windows registry scope glitch testing Compliance Policy",
active=True,
scope=r"fill_registry(HKLM\SOFTWARE\Microsoft\CurrentVersion\Uninstall\test, "
r"some value, INCLUDES, some content)"
)
request.addfinalizer(lambda: policy.delete() if policy.exists else None)
profile = policy_profile_collection.create(
"Windows registry scope glitch testing Compliance Policy",
policies=[policy]
)
request.addfinalizer(lambda: profile.delete() if profile.exists else None)
# Now assign this malformed profile to a VM
vm = VM.factory(InfraVm.get_first_vm(provider=infra_provider).name, infra_provider)
vm.assign_policy_profiles(profile.description)
# It should be screwed here, but do additional check
navigate_to(appliance.server, 'Dashboard')
view = navigate_to(InfraVm, 'All')
assert "except" not in view.entities.title.text.lower()
vm.unassign_policy_profiles(profile.description)
def _ssa_single_vm():
template_name = vm_analysis_provisioning_data['image']
vm_name = f'test-ssa-{fauxfactory.gen_alphanumeric()}-{analysis_type}'
collection = provider.appliance.provider_based_collection(provider)
vm = collection.instantiate(
vm_name,
provider,
template_name=vm_analysis_provisioning_data.image)
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
if "test_ssa_compliance" in request._pyfuncitem.name or provider.one_of(
RHEVMProvider):
provisioning_data = {
"catalog": {
'vm_name': vm_name
},
"environment": {
'automatic_placement': True
}
}
if provider.one_of(RHEVMProvider):
provisioning_data.update({
"network": {
'vlan': partial_match(provision_data['vlan'])
}
})
do_vm_provisioning(vm_name=vm_name,
appliance=appliance,
provider=provider,
provisioning_data=provisioning_data,
template_name=template_name,
request=request,
num_sec=2500)
else:
deploy_template(vm.provider.key,
vm_name,
template_name,
timeout=2500)
vm.wait_to_appear(timeout=900, load_details=False)
request.addfinalizer(lambda: vm.cleanup_on_provider())
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.mgmt.assign_floating_ip(public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned",
vm_name)
vm.mgmt.ensure_state(VmState.RUNNING)
try:
connect_ip, _ = wait_for(find_pingable,
func_args=[vm.mgmt],
timeout="10m",
delay=5,
fail_condition=None)
except TimedOutError:
pytest.fail('Timed out waiting for pingable address on SSA VM')
# 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
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip,
username=credentials[
vm_analysis_provisioning_data.credentials]['username'],
password=credentials[
vm_analysis_provisioning_data.credentials]['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = InfraVm.CfmeRelationship(vm)
cfme_rel.set_relationship(appliance.server.name,
appliance.server_id())
# Close the SSH client if we have one
request.addfinalizer(lambda: vm.ssh.close()
if getattr(vm, 'ssh', None) else None)
return vm
def generated_request(appliance, a_provider, provider_data, provisioning,
template_name, vm_name):
"""Creates a provision request, that is not automatically approved, and returns the search data.
After finishing the test, request should be automatically deleted.
Slightly modified code from :py:module:`cfme.tests.infrastructure.test_provisioning`
"""
first_name = fauxfactory.gen_alphanumeric()
last_name = fauxfactory.gen_alphanumeric()
notes = fauxfactory.gen_alphanumeric()
e_mail = "{}@{}.test".format(first_name, last_name)
host, datastore = map(provisioning.get, ('host', 'datastore'))
vm = InfraVm(name=vm_name,
provider=a_provider,
template_name=template_name)
view = navigate_to(vm, 'Provision')
provisioning_data = {
'request': {
'email': e_mail,
'first_name': first_name,
'last_name': last_name,
'notes': notes
},
'catalog': {
'vm_name': vm_name,
'num_vms': '10'
},
'environment': {
'host_name': {
'name': host
},
'datastore_name': {
'name': datastore
}
},
}
# Same thing, different names. :\
if provider_data["type"] == 'rhevm':
provisioning_data['catalog']['provision_type'] = 'Native Clone'
elif provider_data["type"] == 'virtualcenter':
provisioning_data['catalog']['provision_type'] = 'VMware'
try:
provisioning_data['network'] = {
'vlan': partial_match(provisioning['vlan'])
}
except KeyError:
# provisioning['vlan'] is required for rhevm provisioning
if provider_data["type"] == 'rhevm':
raise pytest.fail(
'rhevm requires a vlan value in provisioning info')
view.form.fill_with(provisioning_data, on_change=view.form.submit_button)
request_cells = {
"Description":
"Provision from [{}] to [{}###]".format(template_name, vm_name),
}
provision_request = appliance.collections.requests.instantiate(
cells=request_cells)
yield provision_request
browser().get(appliance.url)
appliance.server.login_admin()
provision_request.remove_request()
def _ssa_single_vm():
template_name = vm_analysis_provisioning_data['image']
vm_name = 'test-ssa-{}-{}'.format(fauxfactory.gen_alphanumeric(), analysis_type)
collection = provider.appliance.provider_based_collection(provider)
vm = collection.instantiate(vm_name,
provider,
template_name=vm_analysis_provisioning_data.image)
provision_data = vm_analysis_provisioning_data.copy()
del provision_data['image']
if "test_ssa_compliance" in request._pyfuncitem.name:
provisioning_data = {"catalog": {'vm_name': vm_name},
"environment": {'automatic_placement': True}}
do_vm_provisioning(vm_name=vm_name, appliance=appliance, provider=provider,
provisioning_data=provisioning_data, template_name=template_name,
request=request, smtp_test=False, num_sec=2500)
else:
deploy_template(vm.provider.key, vm_name, template_name, timeout=2500)
vm.wait_to_appear(timeout=900, load_details=False)
request.addfinalizer(lambda: vm.delete_from_provider())
if provider.one_of(OpenStackProvider):
public_net = provider.data['public_network']
vm.provider.mgmt.assign_floating_ip(vm.name, public_net)
logger.info("VM %s provisioned, waiting for IP address to be assigned", vm_name)
@wait_for_decorator(timeout="20m", delay=5)
def get_ip_address():
logger.info("Power state for {} vm: {}, is_vm_stopped: {}".format(
vm_name, provider.mgmt.vm_status(vm_name), provider.mgmt.is_vm_stopped(vm_name)))
if provider.mgmt.is_vm_stopped(vm_name):
provider.mgmt.start_vm(vm_name)
ip = provider.mgmt.current_ip_address(vm_name)
logger.info("Fetched IP for %s: %s", vm_name, ip)
return ip is not None
connect_ip = provider.mgmt.get_ip_address(vm_name)
assert connect_ip is not None
# 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
if vm_analysis_provisioning_data['fs-type'] not in ['ntfs', 'fat32']:
logger.info("Waiting for %s to be available via SSH", connect_ip)
ssh_client = ssh.SSHClient(
hostname=connect_ip,
username=credentials[vm_analysis_provisioning_data.credentials]['username'],
password=credentials[vm_analysis_provisioning_data.credentials]['password'],
port=22)
wait_for(ssh_client.uptime, num_sec=3600, handle_exception=True)
vm.ssh = ssh_client
vm.system_type = detect_system_type(vm)
logger.info("Detected system type: %s", vm.system_type)
vm.image = vm_analysis_provisioning_data['image']
vm.connect_ip = connect_ip
# TODO: if rhev and iscsi, it need direct_lun
if provider.type == 'rhevm':
logger.info("Setting a relationship between VM and appliance")
cfme_rel = InfraVm.CfmeRelationship(vm)
cfme_rel.set_relationship(appliance.server.name, appliance.server_id())
# Close the SSH client if we have one
request.addfinalizer(lambda: vm.ssh.close() if getattr(vm, 'ssh', None) else None)
return vm