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)