def test_alert_vm_turned_on_more_than_twice_in_past_15_minutes(
vm_name, vm_crud, provider, request, smtp_test, register_event):
""" Tests alerts for vm turned on more than twice in 15 minutes
Metadata:
test_flag: alerts, provision
"""
alert = explorer.Alert("VM Power On > 2 in last 15 min")
with update(alert):
alert.emails = fauxfactory.gen_email()
setup_for_alerts(request, [alert], "VM Power On", vm_name, provider)
if not provider.mgmt.is_vm_stopped(vm_name):
provider.mgmt.stop_vm(vm_name)
provider.refresh_provider_relationships()
register_event(provider.type, "vm", vm_name, ["vm_power_off"])
vm_crud.wait_for_vm_state_change(vm_crud.STATE_OFF)
for i in range(5):
vm_crud.power_control_from_cfme(option=vm_crud.POWER_ON, cancel=False)
register_event(provider.type, "vm", vm_name,
["vm_power_on", "vm_power_on_req"])
wait_for(lambda: provider.mgmt.is_vm_running(vm_name), num_sec=300)
vm_crud.wait_for_vm_state_change(vm_crud.STATE_ON)
vm_crud.power_control_from_cfme(option=vm_crud.POWER_OFF, cancel=False)
register_event(provider.type, "vm", vm_name,
["vm_power_off", "vm_power_off_req"])
wait_for(lambda: provider.mgmt.is_vm_stopped(vm_name), num_sec=300)
vm_crud.wait_for_vm_state_change(vm_crud.STATE_OFF)
wait_for_alert(smtp_test, alert, delay=16 * 60)
def test_alert_rtp(request, vm_name, smtp_test, provider):
""" Tests a custom alert that uses C&U data to trigger an alert. Since the threshold is set to
zero, it will start firing mails as soon as C&U data are available.
Metadata:
test_flag: alerts, provision, metrics_collection
"""
email = fauxfactory.gen_email()
alert = explorer.Alert(
"Trigger by CPU {}".format(fauxfactory.gen_alpha(length=4)),
active=True,
based_on="VM and Instance",
evaluate=("Real Time Performance", {
"performance_field": "CPU - % Used",
"performance_field_operator": ">",
"performance_field_value": "0",
"performance_trend": "Don't Care",
"performance_time_threshold": "3 Minutes",
}),
notification_frequency="5 Minutes",
emails=email,
)
alert.create()
request.addfinalizer(alert.delete)
setup_for_alerts(request, [alert])
wait_for_alert(smtp_test,
alert,
delay=30 * 60,
additional_checks={
"text": vm_name,
"from_address": email
})
def test_alert_vm_turned_on_more_than_twice_in_past_15_minutes(
vm_name, provider, request, smtp_test, register_event):
""" Tests alerts for vm turned on more than twice in 15 minutes
Metadata:
test_flag: alerts, provision
"""
alert = explorer.Alert("VM Power On > 2 in last 15 min")
with update(alert):
alert.emails = "*****@*****.**"
setup_for_alerts(request, [alert], "VM Power On", vm_name, provider)
# Ok, hairy stuff done, now - hammertime!
register_event(provider.get_yaml_data()['type'], "vm", vm_name,
["vm_power_off"])
register_event(provider.get_yaml_data()['type'], "vm", vm_name,
["vm_power_on"])
# We don't check for *_req events because these happen only if the operation is issued via CFME.
provider.mgmt.stop_vm(vm_name)
wait_for(lambda: provider.mgmt.is_vm_stopped(vm_name), num_sec=240)
for i in range(5):
provider.mgmt.start_vm(vm_name)
wait_for(lambda: provider.mgmt.is_vm_running(vm_name), num_sec=240)
provider.mgmt.stop_vm(vm_name)
wait_for(lambda: provider.mgmt.is_vm_stopped(vm_name), num_sec=240)
wait_for_alert(smtp_test, alert, delay=16 * 60)
def random_alert():
alert = explorer.Alert(fauxfactory.gen_alphanumeric(),
timeline_event=True,
driving_event="Hourly Timer")
alert.create()
yield alert
alert.delete()
def alert_profile(request):
alert = explorer.Alert(fauxfactory.gen_alphanumeric(),
based_on=request.param.TYPE,
timeline_event=True,
driving_event="Hourly Timer")
alert.create()
alert_profile = request.param(fauxfactory.gen_alphanumeric(), [alert])
yield alert_profile
alert.delete()
def test_alert_snmp(request, vm_name, smtp_test, provider, snmp_client):
""" Tests a custom alert that uses C&U data to trigger an alert. Since the threshold is set to
zero, it will start firing mails as soon as C&U data are available. It uses SNMP to catch the
alerts. It uses SNMP v2.
Metadata:
test_flag: alerts, provision, metrics_collection
"""
alert = explorer.Alert(
"Trigger by CPU {}".format(fauxfactory.gen_alpha(length=4)),
active=True,
based_on="VM and Instance",
evaluate=("Real Time Performance", {
"performance_field": "CPU - % Used",
"performance_field_operator": ">",
"performance_field_value": "0",
"performance_trend": "Don't Care",
"performance_time_threshold": "3 Minutes",
}),
notification_frequency="5 Minutes",
snmp_trap={
"hosts":
"127.0.0.1", # The client lives on the appliance due to network reasons
"version": "v2",
"id": "1",
"traps": [("1.2.3", "Integer", "1")]
},
)
alert.create()
request.addfinalizer(alert.delete)
setup_for_alerts(request, [alert])
def _snmp_arrived():
# TODO: More elaborate checking
for trap in snmp_client.get_all():
if trap["source_ip"] != "127.0.0.1":
continue
if trap["trap_version"] != 2:
continue
if trap["oid"] != "1.0":
continue
for var in trap["vars"]:
if var["name"] == "1.2.3" and var["oid"] == "1.2.3" and var[
"value"] == "1":
return True
else:
return False
wait_for(_snmp_arrived,
num_sec=600,
delay=15,
message="SNMP trap arrived.")
def test_alert_timeline_cpu(request, vm_name, provider, ssh, vm_crud):
""" Tests a custom alert that uses C&U data to trigger an alert. It will run a script that makes
a CPU spike in the machine to trigger the threshold. The alert is displayed in the timelines.
Metadata:
test_flag: alerts, provision, metrics_collection
"""
alert = explorer.Alert(
"TL event by CPU {}".format(fauxfactory.gen_alpha(length=4)),
active=True,
based_on="VM and Instance",
evaluate=("Real Time Performance", {
"performance_field": "CPU - % Used",
"performance_field_operator": ">",
"performance_field_value": "20",
"performance_trend": "Don't Care",
"performance_time_threshold": "2 Minutes",
}),
notification_frequency="5 Minutes",
timeline_event=True,
)
alert.create()
request.addfinalizer(alert.delete)
setup_for_alerts(request, [alert])
# Generate a 100% CPU spike for 5 minutes, that should be noticed by CFME.
ssh.cpu_spike(seconds=5 * 60, cpus=4)
def _timeline_event_present():
vm_crud.open_timelines()
select = pytest.sel.Select(
"//select[@name='tl_fl_grp2']") # TODO: Make a timelines module?
pytest.sel.select(select, "Alarm/Status change/Errors")
for event in jstimelines.events():
info = event.block_info()
if info.get("Event Type") != "EVMAlertEvent":
continue
if info.get("Event Source") != "MiqAlert":
continue
if info["Source VM"] == vm_name:
return True
return False
wait_for(_timeline_event_present,
num_sec=30 * 60,
delay=15,
message="timeline event present")
def test_alert_crud(soft_assert):
alert = explorer.Alert(fauxfactory.gen_alphanumeric(),
timeline_event=True,
driving_event="Hourly Timer")
# CR
alert.create()
soft_assert(alert.exists,
"The alert {} does not exist!".format(alert.description))
# U
with update(alert):
alert.notification_frequency = "2 Hours"
sel.force_navigate("control_explorer_alert_edit",
context={"alert_name": alert.description})
soft_assert(
(alert.form.notification_frequency.first_selected_option[0].strip()
) == "2 Hours", "Modification failed!")
# D
alert.delete()
soft_assert(not alert.exists,
"The alert {} exists!".format(alert.description))
def test_vmware_alarm_selection_does_not_fail():
"""Test the bug that causes CFME UI to explode when VMware Alarm type is selected.
Metadata:
test_flag: alerts
"""
alert = explorer.Alert(
"Trigger by CPU {}".format(fauxfactory.gen_alpha(length=4)),
active=True,
based_on="VM and Instance",
evaluate=("VMware Alarm", {}),
notification_frequency="5 Minutes",
)
try:
alert.create()
except CFMEExceptionOccured as e:
pytest.fail("The CFME has thrown an error: {}".format(str(e)))
except Exception as e:
flash.assert_message_contain("must be configured")
else:
pytest.fail("Creating this alert passed although it must fail.")
def test_alert_vm_turned_on_more_than_twice_in_past_15_minutes(
test_vm_power_control, provider_crud, provider_data, provider_mgmt,
provider_type, request, smtp_test):
if len(test_vm_power_control) == 0:
pytest.skip("No power control vm specified!")
test_vm_power_control = test_vm_power_control[0]
alert = explorer.Alert("VM Power On > 2 in last 15 min")
setup_for_alerts(request, [alert], "VM Power On", test_vm_power_control,
provider_data)
# Ok, hairy stuff done, now - hammertime!
provider_mgmt.stop_vm(test_vm_power_control)
wait_for(lambda: provider_mgmt.is_vm_stopped(test_vm_power_control),
num_sec=240)
for i in range(5):
provider_mgmt.start_vm(test_vm_power_control)
wait_for(lambda: provider_mgmt.is_vm_running(test_vm_power_control),
num_sec=240)
provider_mgmt.stop_vm(test_vm_power_control)
wait_for(lambda: provider_mgmt.is_vm_stopped(test_vm_power_control),
num_sec=240)
wait_for_alert(smtp_test, alert, delay=800)
