fixes

Author: haydencarroll-NS1

examples/usage_alerts.py

@@ -6,12 +6,12 @@
 import os
 import sys
 import json
+from ns1 import NS1
+from ns1.config import Config
 
 # Path hackery to ensure we import the local ns1 module
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__),
-                                               '..')))
-
-from ns1 import NS1
+                                                '..')))
 
 # Create NS1 client
 config = {
@@ -26,11 +26,12 @@
 }
 
 # Create a config from dictionary and create the client
-from ns1.config import Config
 c = Config()
 c.loadFromDict(config)
 client = NS1(config=c)
 
+
+
 # Usage Alerts API Examples
 def usage_alerts_example():
     print("\n=== Usage Alerts Examples ===\n")
@@ -90,6 +91,8 @@ def usage_alerts_example():
     except Exception as e:
         print(f"Error deleting alert: {e}")
 
+
+
 # Test validation failures
 def test_validation():
     print("\n=== Validation Tests ===\n")
@@ -127,6 +130,8 @@ def test_validation():
     except ValueError as e:
         print(f"Validation error (expected): {e}")
 
+
+
 if __name__ == '__main__':
     print("Usage Alerts API Examples")
     print("-" * 30)

ns1/__init__.py

@@ -249,7 +249,7 @@ def alerting(self):
         :return: Alerting namespace
         """
         from ns1.alerting import UsageAlertsAPI
-        
+
         # Create or reuse the alerting namespace
         ns = getattr(self, "_alerting_ns", None)
         if ns is None:

ns1/alerting/usage_alerts.py

@@ -5,6 +5,7 @@
     "rum_decision_usage", "filter_chain_usage", "monitor_usage",
 }
 
+
 def _validate(name: str, subtype: str, alert_at_percent: int) -> None:
     if not name:
         raise ValueError("name required")
@@ -13,6 +14,7 @@ def _validate(name: str, subtype: str, alert_at_percent: int) -> None:
     if not isinstance(alert_at_percent, int) or not (1 <= alert_at_percent <= 100):
         raise ValueError("data.alert_at_percent must be int in 1..100")
 
+
 class UsageAlertsAPI:
     """
     Account-scoped usage alerts.

tests/unit/test_usage_alerts.py

@@ -10,7 +10,6 @@
 except ImportError:
     import mock
 
-import json
 
 
 @pytest.fixture
@@ -32,13 +31,14 @@ def usage_alerts_client(config):
     return client
 
 
+
 def test_create_usage_alert(usage_alerts_client):
     """Test creating a usage alert"""
     client = usage_alerts_client
-    
+
     # Create a mock for the _post method in alerting().usage
-    client.alerting()._c._post = mock.MagicMock()
-    client.alerting()._c._post.return_value = {
+    client._post = mock.MagicMock()
+    client._post.return_value = {
         "id": "a1b2c3",
         "name": "Test Alert",
         "type": "account",
@@ -50,12 +50,14 @@ def test_create_usage_alert(usage_alerts_client):
         "updated_at": 1597937213
     }
 
-    alert = client.alerting().usage.create(
-        name="Test Alert",
-        subtype="query_usage",
-        alert_at_percent=85,
-        notifier_list_ids=["n1"]
-    )
+    # Patch the client reference
+    with mock.patch.object(client.alerting().usage, "_c", client):
+        alert = client.alerting().usage.create(
+            name="Test Alert",
+            subtype="query_usage",
+            alert_at_percent=85,
+            notifier_list_ids=["n1"]
+        )
 
     # Verify _post was called with correct arguments
     expected_body = {
@@ -66,7 +68,7 @@ def test_create_usage_alert(usage_alerts_client):
         "notifier_list_ids": ["n1"],
         "zone_names": []
     }
-    client.alerting()._c._post.assert_called_once_with("/alerting/v1/alerts", json=expected_body)
+    client._post.assert_called_once_with("/alerting/v1/alerts", json=expected_body)
 
     # Verify result
     assert alert["id"] == "a1b2c3"
@@ -76,14 +78,15 @@ def test_create_usage_alert(usage_alerts_client):
     assert alert["data"]["alert_at_percent"] == 85
 
 
+
 def test_get_usage_alert(usage_alerts_client):
     """Test retrieving a usage alert"""
     client = usage_alerts_client
     alert_id = "a1b2c3"
 
     # Create a mock for the _get method
-    client.alerting()._c._get = mock.MagicMock()
-    client.alerting()._c._get.return_value = {
+    client._get = mock.MagicMock()
+    client._get.return_value = {
         "id": alert_id,
         "name": "Test Alert",
         "type": "account",
@@ -93,25 +96,28 @@ def test_get_usage_alert(usage_alerts_client):
         "zone_names": []
     }
 
-    alert = client.alerting().usage.get(alert_id)
+    # Patch the client reference
+    with mock.patch.object(client.alerting().usage, "_c", client):
+        alert = client.alerting().usage.get(alert_id)
 
     # Verify _get was called with correct URL
-    client.alerting()._c._get.assert_called_once_with(f"/alerting/v1/alerts/{alert_id}")
+    client._get.assert_called_once_with(f"/alerting/v1/alerts/{alert_id}")
 
     # Verify result
     assert alert["id"] == alert_id
     assert alert["name"] == "Test Alert"
     assert alert["data"]["alert_at_percent"] == 85
 
 
+
 def test_patch_usage_alert(usage_alerts_client):
     """Test patching a usage alert - verify type/subtype are not sent"""
     client = usage_alerts_client
     alert_id = "a1b2c3"
 
     # Create a mock for the _patch method
-    client.alerting()._c._patch = mock.MagicMock()
-    client.alerting()._c._patch.return_value = {
+    client._patch = mock.MagicMock()
+    client._patch.return_value = {
         "id": alert_id,
         "name": "Updated Alert",
         "type": "account",
@@ -121,21 +127,23 @@ def test_patch_usage_alert(usage_alerts_client):
         "zone_names": []
     }
 
-    alert = client.alerting().usage.patch(
-        alert_id, 
-        name="Updated Alert",
-        alert_at_percent=90
-    )
+    # Patch the client reference
+    with mock.patch.object(client.alerting().usage, "_c", client):
+        alert = client.alerting().usage.patch(
+            alert_id,
+            name="Updated Alert",
+            alert_at_percent=90
+        )
 
     # Verify _patch was called with correct arguments
     expected_body = {
         "name": "Updated Alert",
         "data": {"alert_at_percent": 90}
     }
-    client.alerting()._c._patch.assert_called_once_with(f"/alerting/v1/alerts/{alert_id}", json=expected_body)
+    client._patch.assert_called_once_with(f"/alerting/v1/alerts/{alert_id}", json=expected_body)
 
     # Verify type/subtype are not in the arguments
-    call_args = client.alerting()._c._patch.call_args[1]["json"]
+    call_args = client._patch.call_args[1]["json"]
     assert "type" not in call_args
     assert "subtype" not in call_args
 
@@ -145,27 +153,31 @@ def test_patch_usage_alert(usage_alerts_client):
     assert alert["data"]["alert_at_percent"] == 90
 
 
+
 def test_delete_usage_alert(usage_alerts_client):
     """Test deleting a usage alert"""
     client = usage_alerts_client
     alert_id = "a1b2c3"
 
     # Create a mock for the _delete method
-    client.alerting()._c._delete = mock.MagicMock()
+    client._delete = mock.MagicMock()
 
-    client.alerting().usage.delete(alert_id)
+    # Patch the client reference
+    with mock.patch.object(client.alerting().usage, "_c", client):
+        client.alerting().usage.delete(alert_id)
 
     # Verify _delete was called with correct URL
-    client.alerting()._c._delete.assert_called_once_with(f"/alerting/v1/alerts/{alert_id}")
+    client._delete.assert_called_once_with(f"/alerting/v1/alerts/{alert_id}")
+
 
 
 def test_list_usage_alerts(usage_alerts_client):
     """Test listing usage alerts with pagination params"""
     client = usage_alerts_client
 
     # Create a mock for the _get method
-    client.alerting()._c._get = mock.MagicMock()
-    client.alerting()._c._get.return_value = {
+    client._get = mock.MagicMock()
+    client._get.return_value = {
         "limit": 1,
         "next": "next_token",
         "total_results": 2,
@@ -180,17 +192,19 @@ def test_list_usage_alerts(usage_alerts_client):
         ]
     }
 
-    response = client.alerting().usage.list(
-        limit=1,
-        order_descending=True
-    )
+    # Patch the client reference
+    with mock.patch.object(client.alerting().usage, "_c", client):
+        response = client.alerting().usage.list(
+            limit=1,
+            order_descending=True
+        )
 
     # Verify _get was called with correct URL and params
     expected_params = {
         "limit": 1,
         "order_descending": "true"
     }
-    client.alerting()._c._get.assert_called_once_with("/alerting/v1/alerts", params=expected_params)
+    client._get.assert_called_once_with("/alerting/v1/alerts", params=expected_params)
 
     # Verify result
     assert "results" in response
@@ -201,6 +215,7 @@ def test_list_usage_alerts(usage_alerts_client):
     assert response["results"][0]["id"] == "a1"
 
 
+
 def test_validation_threshold_bounds(usage_alerts_client):
     """Test validation of alert_at_percent bounds"""
     client = usage_alerts_client
@@ -232,6 +247,7 @@ def test_validation_threshold_bounds(usage_alerts_client):
     assert "alert_at_percent must be int in 1..100" in str(excinfo.value)
 
 
+
 def test_validation_subtype():
     """Test validation of subtype values"""
     from ns1.alerting import USAGE_SUBTYPES