def test_alert_rtp(request, vm, smtp_test, provider, setup_candu, wait_candu):
""" 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 = alerts.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 random_alert():
alert = alerts.Alert(fauxfactory.gen_alphanumeric(),
timeline_event=True,
driving_event="Hourly Timer")
alert.create()
yield alert
alert.delete()
def alert_profile(request):
alert = alerts.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.description])
yield alert_profile
alert.delete()
def test_alert_crud():
alert = alerts.Alert(fauxfactory.gen_alphanumeric(),
timeline_event=True,
driving_event="Hourly Timer")
# CR
alert.create()
# U
with update(alert):
alert.notification_frequency = "2 Hours"
# D
alert.delete()
def test_alert_vm_turned_on_more_than_twice_in_past_15_minutes(
request, provider, vm, smtp_test, register_event):
""" Tests alerts for vm turned on more than twice in 15 minutes
Metadata:
test_flag: alerts, provision
"""
alert = alerts.Alert("VM Power On > 2 in last 15 min")
with update(alert):
alert.active = True
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()
# preparing events to listen to
register_event(target_type='VmOrTemplate',
target_name=vm.name,
event_type='request_vm_poweroff')
register_event(target_type='VmOrTemplate',
target_name=vm.name,
event_type='vm_poweoff')
vm.wait_for_vm_state_change(vm.STATE_OFF)
for i in range(5):
vm.power_control_from_cfme(option=vm.POWER_ON, cancel=False)
register_event(target_type='VmOrTemplate',
target_name=vm.name,
event_type='request_vm_start')
register_event(target_type='VmOrTemplate',
target_name=vm.name,
event_type='vm_start')
wait_for(lambda: provider.mgmt.is_vm_running(vm.name), num_sec=300)
vm.wait_for_vm_state_change(vm.STATE_ON)
vm.power_control_from_cfme(option=vm.POWER_OFF, cancel=False)
register_event(target_type='VmOrTemplate',
target_name=vm.name,
event_type='request_vm_poweroff')
register_event(target_type='VmOrTemplate',
target_name=vm.name,
event_type='vm_poweroff')
wait_for(lambda: provider.mgmt.is_vm_stopped(vm.name), num_sec=300)
vm.wait_for_vm_state_change(vm.STATE_OFF)
wait_for_alert(smtp_test, alert, delay=16 * 60)
def test_alert_snmp(request, appliance, provider, setup_snmp, setup_candu, vm,
wait_candu):
""" 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
"""
match_string = fauxfactory.gen_alpha(length=8)
alert = alerts.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="1 Minute",
snmp_trap={
"hosts": "127.0.0.1",
"version": "v2",
"id": "info",
"traps": [("1.2.3", "OctetString", "{}".format(match_string))]
},
)
alert.create()
request.addfinalizer(alert.delete)
setup_for_alerts(request, [alert])
def _snmp_arrived():
rc, stdout = appliance.ssh_client.run_command(
"journalctl --no-pager /usr/sbin/snmptrapd | grep {}".format(
match_string))
if rc != 0:
return False
elif stdout:
return True
else:
return False
wait_for(_snmp_arrived,
timeout="30m",
delay=60,
message="SNMP trap arrived.")
def test_alert_timeline_cpu(request, vm_name,
set_performance_capture_threshold, 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 = alerts.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": "10",
"performance_trend": "Don't Care",
"performance_time_threshold": "2 Minutes",
}),
notification_frequency="1 Minute",
timeline_event=True,
)
alert.create()
request.addfinalizer(alert.delete)
setup_for_alerts(request, [alert], vm_name=vm_name)
# Generate a 100% CPU spike for 15 minutes, that should be noticed by CFME.
ssh.cpu_spike(seconds=60 * 15, cpus=2, ensure_user=True)
timeline = vm_crud.open_timelines()
timeline.filter.fill({
"event_category":
"Alarm/Status Change/Errors",
"time_range":
"Days",
"calendar":
"{dt.month}/{dt.day}/{dt.year}".format(dt=datetime.now() +
timedelta(days=1))
})
timeline.filter.apply.click()
events = timeline.chart.get_events()
for event in events:
if alert.description in event.message:
break
else:
pytest.fail(
"The event has not been found on the timeline. Event list: {}".
format(events))
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 = alerts.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_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 = alerts.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.")
