adding delete and update channel changes

Author: mawasthy-lgtm

linode_api4/groups/monitor.py

@@ -378,6 +378,10 @@ def channel_create(
 
         :returns: The newly created :class:`AlertChannel`.
         :rtype: AlertChannel
+
+        .. note::
+           For updating an alert channel, use the ``save()`` method on the :class:`AlertChannel` object.
+           For deleting an alert channel, use the ``delete()`` method directly on the :class:`AlertChannel` object.
         """
         params = {
             "label": label,

linode_api4/objects/monitor.py

@@ -504,10 +504,10 @@ class AlertChannel(Base):
 
     properties = {
         "id": Property(identifier=True),
-        "label": Property(),
+        "label": Property(mutable=True),
         "type": Property(),
         "channel_type": Property(),
-        "details": Property(mutable=False, json_object=ChannelDetails),
+        "details": Property(mutable=True, json_object=ChannelDetails),
         "alerts": Property(mutable=False, json_object=AlertInfo),
         "created": Property(is_datetime=True),
         "updated": Property(is_datetime=True),

test/integration/models/monitor/test_monitor.py

@@ -18,7 +18,11 @@
     MonitorService,
     MonitorServiceToken,
 )
-from linode_api4.objects.monitor import AlertStatus, ChannelDetails, EmailDetails
+from linode_api4.objects.monitor import (
+    AlertStatus,
+    ChannelDetails,
+    EmailDetails,
+)
 
 
 # List all dashboards
@@ -314,12 +318,12 @@ def test_alert_definition_entities(test_linode_client):
         assert entity._type == service_type
 
 
-def test_integration_create_get_delete_alert_channel(test_linode_client):
-    """E2E: create an alert channel, fetch it, then delete it.
+def test_integration_create_get_update_delete_alert_channel(test_linode_client):
+    """E2E: create an alert channel, fetch it, update it, then delete it.
 
     This test creates an alert channel with email details, retrieves it,
-    and then deletes it. It ensures the feature is working end-to-end
-    against the actual API.
+    updates it, and then deletes it. It ensures the full CRUD feature is
+    working end-to-end against the actual API.
     """
     client = test_linode_client
     label = get_test_label() + "-e2e-channel"
@@ -362,11 +366,25 @@ def test_integration_create_get_delete_alert_channel(test_linode_client):
         assert found_channel.label == label
         assert found_channel.channel_type == "email"
 
+        # Update the channel label
+        updated_label = f"{label}-updated"
+        created_channel.label = updated_label
+        result = created_channel.save()
+        assert result is True, "Failed to update channel"
+
+        # Fetch the updated channel to verify the change
+        reloaded_channel = client.load(AlertChannel, created_channel.id)
+        assert (
+            reloaded_channel.label == updated_label
+        ), "Channel label was not updated"
+
     finally:
         if created_channel:
             # Clean up: delete the created channel
             try:
                 created_channel.delete()
             except Exception as e:
                 # Log but don't fail if cleanup fails
-                print(f"Warning: Failed to delete channel {created_channel.id}: {e}")
+                print(
+                    f"Warning: Failed to delete channel {created_channel.id}: {e}"
+                )

test/unit/groups/monitor_api_test.py

@@ -183,54 +183,71 @@ def test_alert_definition_entities(self):
             assert entities[2].url == "/v4/databases/mysql/instances/3"
             assert entities[2]._type == "dbaas"
 
-    def test_create_channel(self):
-        url = "/monitor/alert-channels"
-        result = {
-            "id": 123,
-            "label": "email channel for api change",
+    def test_create_update_delete_alert_channel(self):
+        """
+        E2E test for alert channel CRUD: create, update, and delete.
+        Verifies the full lifecycle of an alert channel.
+        """
+        create_url = "/monitor/alert-channels"
+        channel_id = 789
+        channel_url = f"{create_url}/{channel_id}"
+
+        # Create channel
+        create_response = {
+            "id": channel_id,
+            "label": "Test Channel",
             "type": "user",
             "channel_type": "email",
             "details": {
                 "email": {
-                    "usernames": ["mawasthy_tenant02_admin"],
+                    "usernames": ["test_user"],
                     "recipient_type": "user",
                 }
             },
             "alerts": {
-                "url": "/monitor/alert-channels/123/alerts",
+                "url": f"{channel_url}/alerts",
                 "type": "alerts-definitions",
                 "alert_count": 0,
             },
             "created": "2024-01-01T00:00:00",
             "updated": "2024-01-01T00:00:00",
-            "created_by": "mawasthy_tenant02_admin",
-            "updated_by": "mawasthy_tenant02_admin",
+            "created_by": "test_user",
+            "updated_by": "test_user",
         }
 
-        with self.mock_post(result) as mock_post:
+        with self.mock_post(create_response) as mock_post:
             channel = self.client.monitor.channel_create(
-                label="email channel for api change",
+                label="Test Channel",
                 channel_type="email",
                 details=ChannelDetails(
                     email=EmailDetails(
                         recipient_type="user",
-                        usernames=["mawasthy_tenant02_admin"],
+                        usernames=["test_user"],
                     )
                 ),
             )
 
-            assert mock_post.call_url == url
-            # payload should include the provided fields
-            assert mock_post.call_data["label"] == "email channel for api change"
-            assert mock_post.call_data["channel_type"] == "email"
-            assert "details" in mock_post.call_data
-
+            assert mock_post.call_url == create_url
             assert isinstance(channel, AlertChannel)
-            assert channel.id == 123
-            assert channel.label == "email channel for api change"
-            assert channel.channel_type == "email"
+            assert channel.id == channel_id
+            assert channel.label == "Test Channel"
 
-            # fetch the same response from the client and assert
-            resp = self.client.post(url, data={})
-            assert resp["label"] == "email channel for api change"
-            assert resp["channel_type"] == "email"
+        # Update channel
+        updated_response = create_response.copy()
+        updated_response["label"] = "Test Channel Updated"
+        updated_response["updated"] = "2024-01-02T00:00:00"
+
+        with self.mock_put(updated_response) as mock_put:
+            channel.label = "Test Channel Updated"
+            result = channel.save()
+
+            assert mock_put.call_url == channel_url
+            assert result is True
+            assert channel.label == "Test Channel Updated"
+
+        # Delete channel
+        with self.mock_delete() as mock_delete:
+            result = channel.delete()
+
+            assert mock_delete.call_url == channel_url
+            assert result is True

test/unit/objects/monitor_test.py

@@ -2,7 +2,6 @@
 from test.unit.base import ClientBaseCase
 
 from linode_api4.objects import AlertChannel, MonitorDashboard, MonitorService
-from linode_api4.objects.monitor import ChannelDetails, EmailDetails
 
 
 class MonitorTest(ClientBaseCase):
@@ -171,58 +170,59 @@ def test_alert_channels(self):
         )
         self.assertEqual(channels[0].alerts.alert_count, 0)
 
-    def test_create_channel(self):
-        
+    def test_create_update_delete_channel(self):
+        """
+        Test CRUD operations for AlertChannel: create, update, and delete.
+        Verifies the full lifecycle of an alert channel object.
+        """
+        channel_id = 999
+        url = f"/monitor/alert-channels/{channel_id}"
+
+        # Create the channel
         create_response = {
-            "id": 456,
-            "label": "Email channel for api change",
+            "id": channel_id,
+            "label": "CRUD Test Channel",
             "type": "user",
             "channel_type": "email",
             "details": {
                 "email": {
+                    "usernames": ["crud_user"],
                     "recipient_type": "user",
-                    "usernames": ["mawasthy_tenant02_admin"],
                 }
             },
             "alerts": {
-                "url": "/monitor/alert-channels/456/alerts",
+                "url": f"{url}/alerts",
                 "type": "alerts-definitions",
                 "alert_count": 0,
             },
             "created": "2024-01-01T00:00:00",
             "updated": "2024-01-01T00:00:00",
-            "created_by": "mawasthy_tenant02_admin",
-            "updated_by": "mawasthy_tenant02_admin",
+            "created_by": "crud_user",
+            "updated_by": "crud_user",
         }
 
-        with self.mock_post(create_response) as m:
-            result = self.client.monitor.channel_create(
-                label="Email channel for api change",
-                channel_type="email",
-                details=ChannelDetails(
-                    email=EmailDetails(
-                        recipient_type="user",
-                        usernames=["mawasthy_tenant02_admin"],
-                    )
-                ),
-            )
+        with self.mock_get(create_response) as m_get:
+            channel = self.client.load(AlertChannel, channel_id)
+            self.assertIsInstance(channel, AlertChannel)
+            self.assertEqual(channel.id, channel_id)
+            self.assertEqual(channel.label, "CRUD Test Channel")
 
-        self.assertEqual(m.call_url, "/monitor/alert-channels")
-        self.assertEqual(m.call_data["label"], "Email channel for api change")
-        self.assertEqual(m.call_data["channel_type"], "email")
-        self.assertEqual(
-            m.call_data["details"]["email"]["recipient_type"], "user"
-        )
-        self.assertEqual(
-            m.call_data["details"]["email"]["usernames"], ["mawasthy_tenant02_admin"]
-        )
+        # Update the channel
+        updated_response = create_response.copy()
+        updated_response["label"] = "CRUD Test Channel Updated"
+        updated_response["updated"] = "2024-01-02T00:00:00"
+
+        with self.mock_put(updated_response) as m_put:
+            channel.label = "CRUD Test Channel Updated"
+            result = channel.save()
+
+            self.assertEqual(m_put.call_url, url)
+            self.assertTrue(result)
+            self.assertEqual(channel.label, "CRUD Test Channel Updated")
+
+        # Delete the channel
+        with self.mock_delete() as m_delete:
+            result = channel.delete()
 
-        self.assertIsInstance(result, AlertChannel)
-        self.assertEqual(result.id, 456)
-        self.assertEqual(result.label, "Email channel for api change")
-        self.assertEqual(result.type, "user")
-        self.assertEqual(result.channel_type, "email")
-        self.assertIsNotNone(result.details)
-        self.assertIsNotNone(result.details.email)
-        self.assertEqual(result.details.email.recipient_type, "user")
-        self.assertEqual(result.details.email.usernames, ["mawasthy_tenant02_admin"])
+            self.assertEqual(m_delete.call_url, url)
+            self.assertTrue(result)