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.")