Fixed get_alerts and improved tests - unstable due to server bug with user alerts

Author: wk9874

simvue/client.py

@@ -990,17 +990,23 @@ def get_alerts(
         RuntimeError
             if there was a failure retrieving data from the server
         """
-
         if not run_id:
+            if critical_only:
+                raise RuntimeError(
+                    "critical_only is ambiguous when returning alerts with no run ID specified."
+                )
             return [alert.name if names_only else alert for _, alert in Alert.get()]  # type: ignore
 
-        return [
-            alert.get("name")
-            if names_only
-            else Alert(identifier=alert.get("id"), **alert)
+        _alerts = [
+            Alert(identifier=alert.get("id"), **alert)
             for alert in Run(identifier=run_id).get_alert_details()
-            if not critical_only or alert["status"].get("current") == "critical"
-        ]  # type: ignore
+        ]
+
+        return [
+            alert.name if names_only else alert
+            for alert in _alerts
+            if not critical_only or alert.get_status(run_id) == "critical"
+        ]
 
     @prettify_pydantic
     @pydantic.validate_call

tests/functional/test_client.py

@@ -12,7 +12,7 @@
 from simvue.exception import ObjectNotFoundError
 import simvue.run as sv_run
 import simvue.api.objects as sv_api_obj
-
+from simvue.api.objects.alert.base import AlertBase
 
 @pytest.mark.dependency
 @pytest.mark.client
@@ -24,25 +24,60 @@ def test_get_events(create_test_run: tuple[sv_run.Run, dict]) -> None:
 @pytest.mark.dependency
 @pytest.mark.client
 @pytest.mark.parametrize(
-    "from_run", (True, False)
+    "from_run", (True, False), ids=("from_run", "all_runs")
 )
-def test_get_alerts(create_test_run: tuple[sv_run.Run, dict], from_run: bool) -> None:
-    time.sleep(1.0)
+@pytest.mark.parametrize(
+    "names_only", (True, False), ids=("names_only", "all_details")
+)
+@pytest.mark.parametrize(
+    "critical_only", (True, False), ids=("critical_only", "all_states")
+)
+def test_get_alerts(create_plain_run: tuple[sv_run.Run, dict], from_run: bool, names_only: bool, critical_only: bool) -> None:
+    run, run_data = create_plain_run
+    run_id = run.id
+    unique_id = f"{uuid.uuid4()}".split("-")[0]
+    _id_1 = run.create_user_alert(
+        name=f"user_alert_1_{unique_id}", 
+    )
+    _id_2 = run.create_user_alert(
+        name=f"user_alert_2_{unique_id}", 
+    )
+    _id_3 = run.create_user_alert(
+        name=f"user_alert_3_{unique_id}",
+        attach_to_run=False
+    )
+    run.log_alert(identifier=_id_1, state="critical")
+    time.sleep(2)
+    run.close()
+    
     client = svc.Client()
-    _, run_data = create_test_run
-    if from_run:
-        triggered_alerts_full = client.get_alerts(run_id=create_test_run[1]["run_id"], critical_only=False, names_only=False)
-        assert len(triggered_alerts_full) == 7
-        for alert in triggered_alerts_full:
-            if alert.name == "value_above_1":
-                assert alert["alert"]["status"]["current"] == "critical"
+    
+    if critical_only and not from_run:
+        with pytest.raises(RuntimeError) as e:
+            _alerts = client.get_alerts(run_id=run_id if from_run else None, critical_only=critical_only, names_only=names_only)
+        assert "critical_only is ambiguous when returning alerts with no run ID specified." in str(e.value)
     else:
-        assert (triggered_alerts_full := client.get_alerts(names_only=True, critical_only=False))
-
-        for alert in run_data["created_alerts"]:
-            assert alert in triggered_alerts_full, f"Alert '{alert}' was not triggered"
-
-
+        _alerts = client.get_alerts(run_id=run_id if from_run else None, critical_only=critical_only, names_only=names_only)
+    
+        if names_only:
+            assert all(isinstance(item, str) for item in _alerts)
+        else:
+            assert all(isinstance(item, AlertBase) for item in _alerts)            
+            _alerts = [alert.name for alert in _alerts]
+            
+        assert f"user_alert_1_{unique_id}" in _alerts
+            
+        if not from_run:
+            assert len(_alerts) > 2
+            assert f"user_alert_3_{unique_id}" in _alerts
+        else:
+            assert f"user_alert_3_{unique_id}" not in _alerts
+            if critical_only:
+                assert len(_alerts) == 1
+            else:
+                assert len(_alerts) == 2
+                assert f"user_alert_2_{unique_id}" in _alerts
+            
 @pytest.mark.dependency
 @pytest.mark.client
 def test_get_run_id_from_name(create_test_run: tuple[sv_run.Run, dict]) -> None: