def test_check_package_presence(request, compliance_vm, analysis_profile):
"""This test checks compliance by presence of a certain "kernel" package which is expected
to be present on the full_template."""
condition = VMCondition(
"Compliance testing condition {}".format(
fauxfactory.gen_alphanumeric(8)),
expression=
("fill_find(field=VM and Instance.Guest Applications : Name, "
"skey=STARTS WITH, value=kernel, check=Check Count, ckey= = , cvalue=1)"
))
request.addfinalizer(lambda: diaper(condition.delete))
condition.create()
policy = VMCompliancePolicy("Compliance {}".format(
fauxfactory.gen_alphanumeric(8)))
request.addfinalizer(lambda: diaper(policy.delete))
policy.create()
policy.assign_conditions(condition)
profile = PolicyProfile("Compliance PP {}".format(
fauxfactory.gen_alphanumeric(8)),
policies=[policy])
request.addfinalizer(lambda: diaper(profile.delete))
profile.create()
compliance_vm.assign_policy_profiles(profile.description)
request.addfinalizer(
lambda: compliance_vm.unassign_policy_profiles(profile.description))
do_scan(compliance_vm)
assert compliance_vm.check_compliance()
def test_check_compliance_history(request, virtualcenter_provider, vmware_vm):
"""This test checks if compliance history link in a VM details screen work.
Steps:
* Create any VM compliance policy
* Assign it to a policy profile
* Assign the policy profile to any VM
* Perform the compliance check for the VM
* Go to the VM details screen
* Click on "History" row in Compliance InfoBox
Result:
Compliance history screen with last 10 checks should be opened
"""
policy = VMCompliancePolicy(
"Check compliance history policy {}".format(fauxfactory.gen_alpha()),
active=True,
scope="fill_field(VM and Instance : Name, INCLUDES, {})".format(
vmware_vm.name))
request.addfinalizer(lambda: policy.delete() if policy.exists else None)
policy.create()
policy_profile = PolicyProfile(policy.description, policies=[policy])
request.addfinalizer(lambda: policy_profile.delete()
if policy_profile.exists else None)
policy_profile.create()
virtualcenter_provider.assign_policy_profiles(policy_profile.description)
request.addfinalizer(lambda: virtualcenter_provider.
unassign_policy_profiles(policy_profile.description))
vmware_vm.check_compliance()
vmware_vm.open_details(["Compliance", "History"])
appliance = get_or_create_current_appliance()
history_screen_title = Text(appliance.browser.widgetastic,
"//span[@id='explorer_title_text']").text
assert history_screen_title == '"Compliance History" for Virtual Machine "{}"'.format(
vmware_vm.name)
def test_check_package_presence(request, fleecing_vm, ssh_client, analysis_profile):
"""This test checks compliance by presence of a certain cfme-appliance package which is expected
to be present on an appliance."""
# TODO: If we step out from provisioning a full appliance for fleecing, this might need revisit
condition = VMCondition(
"Compliance testing condition {}".format(fauxfactory.gen_alphanumeric(8)),
expression=("fill_find(field=VM and Instance.Guest Applications : Name, "
"skey=STARTS WITH, value=cfme-appliance, check=Check Count, ckey= = , cvalue=1)")
)
request.addfinalizer(lambda: diaper(condition.delete))
policy = VMCompliancePolicy("Compliance {}".format(fauxfactory.gen_alphanumeric(8)))
request.addfinalizer(lambda: diaper(policy.delete))
policy.create()
policy.assign_conditions(condition)
profile = PolicyProfile(
"Compliance PP {}".format(fauxfactory.gen_alphanumeric(8)),
policies=[policy]
)
request.addfinalizer(lambda: diaper(profile.delete))
profile.create()
fleecing_vm.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: fleecing_vm.unassign_policy_profiles(profile.description))
with update(analysis_profile):
analysis_profile.categories = [
"check_services", "check_accounts", "check_software", "check_vmconfig", "check_system"]
do_scan(fleecing_vm)
assert fleecing_vm.check_compliance_and_wait()
def test_check_files(request, compliance_vm, analysis_profile):
"""This test checks presence and contents of a certain file. Due to caching, an existing file
is checked.
"""
check_file_name = "/etc/hosts"
check_file_contents = "127.0.0.1"
condition = VMCondition(
"Compliance testing condition {}".format(fauxfactory.gen_alphanumeric(8)),
expression=("fill_find(VM and Instance.Files : Name, "
"=, {}, Check Any, Contents, INCLUDES, {})".format(
check_file_name, check_file_contents))
)
request.addfinalizer(lambda: diaper(condition.delete))
condition.create()
policy = VMCompliancePolicy("Compliance {}".format(fauxfactory.gen_alphanumeric(8)))
request.addfinalizer(lambda: diaper(policy.delete))
policy.create()
policy.assign_conditions(condition)
profile = PolicyProfile(
"Compliance PP {}".format(fauxfactory.gen_alphanumeric(8)),
policies=[policy]
)
request.addfinalizer(lambda: diaper(profile.delete))
profile.create()
compliance_vm.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: compliance_vm.unassign_policy_profiles(profile.description))
with update(analysis_profile):
analysis_profile.files = [(check_file_name, True)]
do_scan(compliance_vm, ("Configuration", "Files"))
assert compliance_vm.check_compliance()
def test_check_files(request, fleecing_vm, ssh_client, analysis_profile):
"""This test checks presence and contents of a certain file. Due to caching, an existing file
is checked.
"""
check_file_name = "/etc/sudo.conf"
check_file_contents = "sudoers_policy" # The file contains: `Plugin sudoers_policy sudoers.so`
condition = VMCondition(
"Compliance testing condition {}".format(fauxfactory.gen_alphanumeric(8)),
expression=("fill_find(VM and Instance.Files : Name, "
"=, {}, Check Any, Contents, INCLUDES, {})".format(
check_file_name, check_file_contents))
)
request.addfinalizer(lambda: diaper(condition.delete))
policy = VMCompliancePolicy("Compliance {}".format(fauxfactory.gen_alphanumeric(8)))
request.addfinalizer(lambda: diaper(policy.delete))
policy.create()
policy.assign_conditions(condition)
profile = PolicyProfile(
"Compliance PP {}".format(fauxfactory.gen_alphanumeric(8)),
policies=[policy]
)
request.addfinalizer(lambda: diaper(profile.delete))
profile.create()
fleecing_vm.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: fleecing_vm.unassign_policy_profiles(profile.description))
with update(analysis_profile):
analysis_profile.files = [(check_file_name, True)]
analysis_profile.categories = [
"check_services", "check_accounts", "check_software", "check_vmconfig", "check_system"]
do_scan(fleecing_vm, ("Configuration", "Files"))
assert fleecing_vm.check_compliance_and_wait()
def test_check_files(request, compliance_vm, analysis_profile):
"""This test checks presence and contents of a certain file. Due to caching, an existing file
is checked.
"""
check_file_name = "/etc/hosts"
check_file_contents = "127.0.0.1"
condition = VMCondition(
"Compliance testing condition {}".format(
fauxfactory.gen_alphanumeric(8)),
expression=("fill_find(VM and Instance.Files : Name, "
"=, {}, Check Any, Contents, INCLUDES, {})".format(
check_file_name, check_file_contents)))
request.addfinalizer(lambda: diaper(condition.delete))
condition.create()
policy = VMCompliancePolicy("Compliance {}".format(
fauxfactory.gen_alphanumeric(8)))
request.addfinalizer(lambda: diaper(policy.delete))
policy.create()
policy.assign_conditions(condition)
profile = PolicyProfile("Compliance PP {}".format(
fauxfactory.gen_alphanumeric(8)),
policies=[policy])
request.addfinalizer(lambda: diaper(profile.delete))
profile.create()
compliance_vm.assign_policy_profiles(profile.description)
request.addfinalizer(
lambda: compliance_vm.unassign_policy_profiles(profile.description))
with update(analysis_profile):
analysis_profile.files = [(check_file_name, True)]
do_scan(compliance_vm, ("Configuration", "Files"))
assert compliance_vm.check_compliance()
def policy_for_testing(policy_name, policy_profile_name, provider):
policy = HostCompliancePolicy(policy_name)
policy.create()
policy_profile = PolicyProfile(policy_profile_name, policies=[policy])
policy_profile.create()
yield policy
policy_profile.delete()
policy.delete()
def policy_profile(request):
policy = VMControlPolicy(fauxfactory.gen_alpha())
policy.create()
request.addfinalizer(policy.delete)
profile = PolicyProfile(fauxfactory.gen_alpha(), policies=[policy])
profile.create()
request.addfinalizer(profile.delete)
return profile
def test_vm_create(request, vm_crud, provider, register_event):
""" Test whether vm_create_complete event is emitted.
Prerequisities:
* A provider that is set up and able to deploy VMs
Steps:
* Create a Control setup (action, policy, profile) that apply a tag on a VM when
``VM Create Complete`` event comes
* Deploy the VM outside of CFME (directly in the provider)
* Refresh provider relationships and wait for VM to appear
* Assert the tag appears.
Metadata:
test_flag: provision
"""
action = Action(
fauxfactory.gen_alpha(),
"Tag",
dict(tag=("My Company Tags", "Environment", "Development")))
action.create()
request.addfinalizer(action.delete)
policy = VMControlPolicy(fauxfactory.gen_alpha())
policy.create()
request.addfinalizer(policy.delete)
policy.assign_events("VM Create Complete")
request.addfinalizer(policy.assign_events)
policy.assign_actions_to_event("VM Create Complete", action)
profile = PolicyProfile(fauxfactory.gen_alpha(), policies=[policy])
profile.create()
request.addfinalizer(profile.delete)
provider.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: provider.unassign_policy_profiles(profile.description))
event = EventBuilder(get_or_create_current_appliance()).new_event(target_type='VmOrTemplate',
target_name=vm_crud.name,
event_type='vm_create')
register_event(event)
vm_crud.create_on_provider()
provider.refresh_provider_relationships()
vm_crud.wait_to_appear()
def _check():
return any(tag.category.display_name == "Environment" and tag.display_name == "Development"
for tag in vm_crud.get_tags())
wait_for(_check, num_sec=300, delay=15, message="tags to appear")
def test_vm_create(request, vm_crud, provider, register_event):
""" Test whether vm_create_complete event is emitted.
Prerequisities:
* A provider that is set up and able to deploy VMs
Steps:
* Create a Control setup (action, policy, profile) that apply a tag on a VM when
``VM Create Complete`` event comes
* Deploy the VM outside of CFME (directly in the provider)
* Refresh provider relationships and wait for VM to appear
* Assert the tag appears.
Metadata:
test_flag: provision
"""
action = Action(
fauxfactory.gen_alpha(), "Tag",
dict(tag=("My Company Tags", "Environment", "Development")))
action.create()
request.addfinalizer(action.delete)
policy = VMControlPolicy(fauxfactory.gen_alpha())
policy.create()
request.addfinalizer(policy.delete)
policy.assign_events("VM Create Complete")
request.addfinalizer(policy.assign_events)
policy.assign_actions_to_event("VM Create Complete", action)
profile = PolicyProfile(fauxfactory.gen_alpha(), policies=[policy])
profile.create()
request.addfinalizer(profile.delete)
provider.assign_policy_profiles(profile.description)
request.addfinalizer(
lambda: provider.unassign_policy_profiles(profile.description))
register_event(target_type='VmOrTemplate',
target_name=vm_crud.name,
event_type='vm_create')
vm_crud.create_on_provider()
provider.refresh_provider_relationships()
vm_crud.wait_to_appear()
def _check():
return any(tag.category.display_name == "Environment"
and tag.display_name == "Development"
for tag in vm_crud.get_tags())
wait_for(_check, num_sec=300, delay=15, message="tags to appear")
def create_policy_profile(request):
random_string = fauxfactory.gen_alpha()
policy = VMControlPolicy(random_string)
policy.create()
policy_profile = PolicyProfile(random_string, [policy])
policy_profile.create()
@request.addfinalizer
def _delete():
while policy_profile.exists:
policy_profile.delete()
if policy.exists:
policy.delete()
return policy_profile
def create_policy_profile(request):
random_string = fauxfactory.gen_alpha()
policy = VMControlPolicy(random_string)
policy.create()
policy_profile = PolicyProfile(random_string, [policy])
policy_profile.create()
@request.addfinalizer
def _delete():
while policy_profile.exists:
policy_profile.delete()
if policy.exists:
policy.delete()
return policy_profile
def policy_profile(request, instance):
collected_files = [
{"Name": "/etc/redhat-access-insights/machine-id", "Collect Contents?": True},
{"Name": ssa_expect_file, "Collect Contents?": True},
]
analysis_profile_name = 'ssa_analysis_{}'.format(fauxfactory.gen_alphanumeric())
analysis_profile = configuration.AnalysisProfile(name=analysis_profile_name,
description=analysis_profile_name,
profile_type='VM',
categories=["check_system"],
files=collected_files)
if analysis_profile.exists:
analysis_profile.delete()
analysis_profile.create()
request.addfinalizer(analysis_profile.delete)
action = Action(
'ssa_action_{}'.format(fauxfactory.gen_alpha()),
"Assign Profile to Analysis Task",
dict(analysis_profile=analysis_profile_name))
if action.exists:
action.delete()
action.create()
request.addfinalizer(action.delete)
policy = VMControlPolicy('ssa_policy_{}'.format(fauxfactory.gen_alpha()))
if policy.exists:
policy.delete()
policy.create()
request.addfinalizer(policy.delete)
policy.assign_events("VM Analysis Start")
request.addfinalizer(policy.assign_events)
policy.assign_actions_to_event("VM Analysis Start", action)
profile = PolicyProfile('ssa_policy_profile_{}'.format(fauxfactory.gen_alpha()),
policies=[policy])
if profile.exists:
profile.delete()
profile.create()
request.addfinalizer(profile.delete)
instance.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: instance.unassign_policy_profiles(profile.description))
def policy_for_testing(policy_name, policy_profile_name, provider):
policy = HostCompliancePolicy(policy_name)
policy.create()
policy_profile = PolicyProfile(policy_profile_name, policies=[policy])
policy_profile.create()
yield policy
policy_profile.delete()
policy.delete()
def test_check_compliance_history(request, virtualcenter_provider, vmware_vm):
"""This test checks if compliance history link in a VM details screen work.
Steps:
* Create any VM compliance policy
* Assign it to a policy profile
* Assign the policy profile to any VM
* Perform the compliance check for the VM
* Go to the VM details screen
* Click on "History" row in Compliance InfoBox
Result:
Compliance history screen with last 10 checks should be opened
"""
policy = VMCompliancePolicy(
"Check compliance history policy {}".format(fauxfactory.gen_alpha()),
active=True,
scope="fill_field(VM and Instance : Name, INCLUDES, {})".format(vmware_vm.name)
)
request.addfinalizer(lambda: policy.delete() if policy.exists else None)
policy.create()
policy_profile = PolicyProfile(
policy.description,
policies=[policy]
)
request.addfinalizer(lambda: policy_profile.delete() if policy_profile.exists else None)
policy_profile.create()
virtualcenter_provider.assign_policy_profiles(policy_profile.description)
request.addfinalizer(lambda: virtualcenter_provider.unassign_policy_profiles(
policy_profile.description))
vmware_vm.check_compliance()
vmware_vm.open_details(["Compliance", "History"])
appliance = get_or_create_current_appliance()
history_screen_title = Text(appliance.browser.widgetastic,
"//span[@id='explorer_title_text']").text
assert history_screen_title == '"Compliance History" for Virtual Machine "{}"'.format(
vmware_vm.name)
def test_check_package_presence(request, compliance_vm, analysis_profile):
"""This test checks compliance by presence of a certain "kernel" package which is expected
to be present on the full_template."""
condition = VMCondition(
"Compliance testing condition {}".format(fauxfactory.gen_alphanumeric(8)),
expression=("fill_find(field=VM and Instance.Guest Applications : Name, "
"skey=STARTS WITH, value=kernel, check=Check Count, ckey= = , cvalue=1)")
)
request.addfinalizer(lambda: diaper(condition.delete))
condition.create()
policy = VMCompliancePolicy("Compliance {}".format(fauxfactory.gen_alphanumeric(8)))
request.addfinalizer(lambda: diaper(policy.delete))
policy.create()
policy.assign_conditions(condition)
profile = PolicyProfile(
"Compliance PP {}".format(fauxfactory.gen_alphanumeric(8)),
policies=[policy]
)
request.addfinalizer(lambda: diaper(profile.delete))
profile.create()
compliance_vm.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: compliance_vm.unassign_policy_profiles(profile.description))
do_scan(compliance_vm)
assert compliance_vm.check_compliance()
def test_scope_windows_registry_stuck(request, setup_a_provider):
"""If you provide Scope checking windows registry, it messes CFME up. Recoverable."""
policy = 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)
policy.create()
profile = PolicyProfile(
"Windows registry scope glitch testing Compliance Policy",
policies=[policy]
)
request.addfinalizer(lambda: profile.delete() if profile.exists else None)
profile.create()
# Now assign this malformed profile to a VM
vm = VM.factory(Vm.get_first_vm_title(provider=setup_a_provider), setup_a_provider)
vm.assign_policy_profiles(profile.description)
# It should be screwed here, but do additional check
navigate_to(Server, 'Dashboard')
navigate_to(Vm, 'All')
assert "except" not in pytest.sel.title().lower()
vm.unassign_policy_profiles(profile.description)
def test_scope_windows_registry_stuck(request, infra_provider):
"""If you provide Scope checking windows registry, it messes CFME up. Recoverable."""
policy = 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)
policy.create()
profile = PolicyProfile(
"Windows registry scope glitch testing Compliance Policy",
policies=[policy]
)
request.addfinalizer(lambda: profile.delete() if profile.exists else None)
profile.create()
# Now assign this malformed profile to a VM
vm = VM.factory(Vm.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(Server, 'Dashboard')
navigate_to(Vm, 'All')
assert "except" not in pytest.sel.title().lower()
vm.unassign_policy_profiles(profile.description)
def policy_profile(request, instance):
collected_files = [
{
"Name": "/etc/redhat-access-insights/machine-id",
"Collect Contents?": True
},
{
"Name": ssa_expect_file,
"Collect Contents?": True
},
]
analysis_profile_name = 'ssa_analysis_{}'.format(
fauxfactory.gen_alphanumeric())
analysis_profile = configuration.AnalysisProfile(
name=analysis_profile_name,
description=analysis_profile_name,
profile_type='VM',
categories=["check_system"],
files=collected_files)
if analysis_profile.exists:
analysis_profile.delete()
analysis_profile.create()
request.addfinalizer(analysis_profile.delete)
action = Action('ssa_action_{}'.format(fauxfactory.gen_alpha()),
"Assign Profile to Analysis Task",
dict(analysis_profile=analysis_profile_name))
if action.exists:
action.delete()
action.create()
request.addfinalizer(action.delete)
policy = VMControlPolicy('ssa_policy_{}'.format(fauxfactory.gen_alpha()))
if policy.exists:
policy.delete()
policy.create()
request.addfinalizer(policy.delete)
policy.assign_events("VM Analysis Start")
request.addfinalizer(policy.assign_events)
policy.assign_actions_to_event("VM Analysis Start", action)
profile = PolicyProfile('ssa_policy_profile_{}'.format(
fauxfactory.gen_alpha()),
policies=[policy])
if profile.exists:
profile.delete()
profile.create()
request.addfinalizer(profile.delete)
instance.assign_policy_profiles(profile.description)
request.addfinalizer(
lambda: instance.unassign_policy_profiles(profile.description))
def policy_for_testing(vmware_vm, provider, ansible_action):
policy = VMControlPolicy(
fauxfactory.gen_alpha(),
scope="fill_field(VM and Instance : Name, INCLUDES, {})".format(
vmware_vm.name))
policy.create()
policy.assign_actions_to_event("Tag Complete",
[ansible_action.description])
policy_profile = PolicyProfile(fauxfactory.gen_alpha(), policies=[policy])
policy_profile.create()
provider.assign_policy_profiles(policy_profile.description)
yield
policy.assign_events()
provider.unassign_policy_profiles(policy_profile.description)
policy_profile.delete()
policy.delete()
def test_folder_field_scope(request, vmware_provider, vmware_vm):
"""This test tests the bug that makes the folder filter in expression not work.
Prerequisities:
* A VMware provider.
* A VM on the provider.
* A tag to assign.
Steps:
* Read the VM's 'Parent Folder Path (VMs & Templates)' from its summary page.
* Create an action for assigning the tag to the VM.
* Create a policy, for scope use ``Field``, field name
``VM and Instance : Parent Folder Path (VMs & Templates)``, ``INCLUDES`` and the
folder name as stated on the VM's summary page.
* Assign the ``VM Discovery`` event to the policy.
* Assign the action to the ``VM Discovery`` event.
* Create a policy profile and assign the policy to it.
* Assign the policy profile to the provider.
* Delete the VM from the CFME database.
* Initiate provider refresh and wait for VM to appear again.
* Assert that the VM gets tagged by the tag.
"""
# Retrieve folder location
folder = None
tags = vmware_vm.get_tags()
if any(tag.category.display_name == "Parent Folder Path (VMs & Templates)" for tag in tags):
folder = ', '.join(
item.display_name for item in
[tag for tag in tags
if tag.category.display_name == "Parent Folder Path (VMs & Templates)"])
logger.info("Detected folder: %s", folder)
else:
pytest.fail("Could not read the folder from the tags:\n{}".format(repr(tags)))
# Create Control stuff
action = Action(
fauxfactory.gen_alpha(),
"Tag", dict(tag=("My Company Tags", "Service Level", "Platinum")))
action.create()
request.addfinalizer(action.delete)
policy = VMControlPolicy(
fauxfactory.gen_alpha(),
scope=(
"fill_field(VM and Instance : Parent Folder Path (VMs & Templates), "
"INCLUDES, {})".format(folder)))
policy.create()
request.addfinalizer(policy.delete)
policy.assign_events("VM Discovery")
request.addfinalizer(policy.assign_events) # Unassigns
policy.assign_actions_to_event("VM Discovery", action)
profile = PolicyProfile(fauxfactory.gen_alpha(), policies=[policy])
profile.create()
request.addfinalizer(profile.delete)
# Assign policy profile to the provider
vmware_provider.assign_policy_profiles(profile.description)
request.addfinalizer(lambda: vmware_provider.unassign_policy_profiles(profile.description))
# Delete and rediscover the VM
vmware_vm.delete()
vmware_vm.wait_for_delete()
vmware_provider.refresh_provider_relationships()
vmware_vm.wait_to_appear()
# Wait for the tag to appear
wait_for(
vmware_vm.get_tags, num_sec=600, delay=15,
fail_condition=lambda tags: not any(
tag.category.display_name == "Service Level" and tag.display_name == "Platinum"
for tag in tags),
message="vm be tagged")
