lvi-api-client 0.2.7__tar.gz → 0.2.9__tar.gz

{lvi_api_client-0.2.7 → lvi_api_client-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lvi-api-client
-Version: 0.2.7
+Version: 0.2.9
 Summary: LogicVein API Client Library
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

lvi_api_client-0.2.9/VERSION

@@ -0,0 +1 @@
+0.2.9

{lvi_api_client-0.2.7 → lvi_api_client-0.2.9}/src/logicvein/lvi_api_client.py

@@ -3,7 +3,7 @@ import json
 import logging
 import os
 import re
-from typing import Any, Dict, List, MutableMapping, Optional, Sequence, Tuple, Union
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 from xml.etree import ElementTree
 from xml.sax.saxutils import escape
 
@@ -211,7 +211,10 @@ class LogicVeinAPIClient:
             f"LogicVeinAPIClient initialized: host={self.host}, username={self.username}, using_token={bool(self.api_token)}, ignore_env={ignore_env}"
         )
         self.base_url = f"https://{self.host}/rest"
-        self.headers: MutableMapping[str, Union[str, bytes]] = {"Content-Type": "application/json"}
+        # The session holds this same mapping, so its headers are exactly these (requests' defaults are not sent).
+        self.headers: requests.structures.CaseInsensitiveDict[str] = requests.structures.CaseInsensitiveDict(
+            {"Content-Type": "application/json"}
+        )
         if self.api_token:
             self.headers["Authorization"] = f"Bearer {self.api_token}"
         self.lvi_client = requests.Session()
@@ -4394,41 +4397,69 @@ class LogicVeinAPIClient:
         return None
 
     def delete_alert_policy(self, policy_id: int, reassign_policy_id: int = -1) -> bool:
-        """Delete an alert policy, with its actions.
+        """Delete an alert policy, with its actions, refusing one still in use.
 
-        Calls Collection.deleteAlertPolicy, with the parameters the web UI sends. The server
-        refuses ``policyId`` alone. The UI asks first whether the policy is referenced
-        (:meth:`is_alert_policy_referenced`); what the server does with the references of a
-        referenced policy deleted with ``reassign_policy_id`` -1 has not been measured.
+        A policy that alert triggers still use (:meth:`is_alert_policy_referenced`) may not be
+        deleted on its own: as in the web UI, which asks for an alternate policy to take those
+        triggers, ``reassign_policy_id`` must name another existing policy. Otherwise this
+        raises before deleting anything.
 
-        The server's answer is not relied on: the policies are read back afterwards. An answer
-        that cannot show whether the policy is gone raises rather than reading as deleted, and
-        errors from either call (``LogicVeinAPIError``, ``requests`` errors) propagate.
+        Calls Collection.deleteAlertPolicy with ``policyId`` and ``reassignPolicyId``, as the UI
+        does; the server refuses ``policyId`` alone. It answers true when it deletes the policy
+        and false for an unknown ID. The policies are then read back, and the result is whether
+        this one is gone: an answer that cannot show it raises rather than reading as deleted.
+        Errors from the calls themselves (``LogicVeinAPIError``, ``requests`` errors) propagate.
 
         Args:
             policy_id (int): The ID of the policy to delete.
-            reassign_policy_id (int): The policy to move its references to, or -1 for none.
+            reassign_policy_id (int): The policy to move its triggers to, required when the
+                policy is in use; -1 for none.
 
         Returns:
             bool: True if the policy is gone afterwards.
 
         Raises:
-            ValueError: If the read-back answer has no list of policies, or a policy without an ID.
-        """
+            ValueError: If the policy is in use and no other existing policy is given to take
+                its triggers, if the policies cannot be read (an answer with no list of policies,
+                or a policy without an ID), or if the reference check does not answer true or false.
+        """
+        if reassign_policy_id == policy_id:
+            raise ValueError(f"Alert policy {policy_id} cannot take its own triggers; name another policy")
+        in_use = self.is_alert_policy_referenced(policy_id)
+        if reassign_policy_id != -1:
+            if reassign_policy_id not in self._alert_policy_ids():
+                raise ValueError(f"Alert policy {reassign_policy_id}, to take the triggers, does not exist")
+        elif in_use:
+            raise ValueError(
+                f"Alert policy {policy_id} is used by alert triggers, so it may not be deleted until another "
+                "policy takes them: pass reassign_policy_id"
+            )
         self.call("Collection.deleteAlertPolicy", policyId=policy_id, reassignPolicyId=reassign_policy_id)
-        remaining = self._search_alert_policies([], [], "policyName", False, 500, strict=True)
-        ids = [policy.get("policyId") if isinstance(policy, dict) else None for policy in remaining]
-        if not all(isinstance(found, int) for found in ids):
+        return policy_id not in self._alert_policy_ids()
+
+    def _alert_policy_ids(self) -> List[int]:
+        """Read the IDs of every alert policy, failing on an answer that cannot list them.
+
+        Returns:
+            List[int]: The IDs.
+
+        Raises:
+            ValueError: If the answer has no list of policies, or a policy without an ID.
+        """
+        policies = self._search_alert_policies([], [], "policyName", False, 500, strict=True)
+        ids = [policy.get("policyId") if isinstance(policy, dict) else None for policy in policies]
+        known = [found for found in ids if isinstance(found, int)]
+        if len(known) != len(ids):
             raise ValueError("Collection.searchAlertPolicies answered with a policy that has no ID")
-        return policy_id not in ids
+        return known
 
     def is_alert_policy_referenced(self, policy_id: int) -> bool:
         """Check whether anything refers to an alert policy.
 
-        Calls Collection.isAlertPolicyReferenced, which the web UI calls before deleting one.
-        Monitor triggers name the policy they alert through, but they are not the only
-        references counted: on the lab, a policy no trigger names also answered true. An
-        unknown ID answers false.
+        Calls Collection.isAlertPolicyReferenced, which the web UI calls before deleting one: a
+        policy in use may only be deleted with another policy to take its alert triggers (see
+        :meth:`delete_alert_policy`). On the lab, a policy no monitor trigger names also
+        answered true, so more than monitor triggers count. An unknown ID answers false.
 
         Args:
             policy_id (int): The ID of the policy.

{lvi_api_client-0.2.7 → lvi_api_client-0.2.9}/src/lvi_api_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lvi-api-client
-Version: 0.2.7
+Version: 0.2.9
 Summary: LogicVein API Client Library
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{lvi_api_client-0.2.7 → lvi_api_client-0.2.9}/tests/test_check_version_bump.py

@@ -7,6 +7,7 @@ import pytest
 
 _PATH = Path(__file__).resolve().parent.parent / "scripts" / "ci" / "check_version_bump.py"
 _SPEC = importlib.util.spec_from_file_location("check_version_bump", _PATH)
+assert _SPEC is not None and _SPEC.loader is not None, _PATH
 check = importlib.util.module_from_spec(_SPEC)
 _SPEC.loader.exec_module(check)
 

{lvi_api_client-0.2.7 → lvi_api_client-0.2.9}/tests/test_lvi_api_client.py

@@ -48,6 +48,16 @@ class TestLogicVeinAPIClientUnit:
             assert "Authorization" in client.headers
             assert client.headers["Authorization"] == "Bearer test-token-123"
 
+    def test_the_session_sends_only_the_clients_headers(self, mock_env):
+        """The session holds the client's own header mapping, with no requests defaults added."""
+        client = LogicVeinAPIClient()
+        assert client.lvi_client.headers is client.headers
+        assert dict(client.lvi_client.headers) == {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer test-token-123",
+        }
+        assert client.lvi_client.headers["content-type"] == "application/json"
+
     def test_initialization_with_kwargs(self, monkeypatch):
         """Test client initialization with kwargs instead of env vars."""
         # Clear env vars so kwargs take precedence

{lvi_api_client-0.2.7 → lvi_api_client-0.2.9}/tests/test_server_request_shapes.py

@@ -625,31 +625,77 @@ class TestDeployingASet:
 class TestAlertPolicies:
     """Deleting alert policies and the checks the web UI makes around saving and deleting them."""
 
-    def test_a_delete_sends_what_the_ui_sends_and_reads_the_policies_back(self, connect):
+    @staticmethod
+    def listing(*ids):
+        return {"policies": [{"policyId": i, "policyName": f"p{i}"} for i in ids]}
+
+    def test_a_delete_of_a_policy_not_in_use_sends_what_the_ui_sends_and_reads_the_policies_back(self, connect):
         client, server = connect(
             {
-                "Collection.deleteAlertPolicy": None,
-                "Collection.searchAlertPolicies": {"policies": [{"policyId": 1, "policyName": "kept"}]},
+                "Collection.isAlertPolicyReferenced": False,
+                "Collection.deleteAlertPolicy": True,
+                "Collection.searchAlertPolicies": self.listing(1),
             }
         )
         assert client.delete_alert_policy(65) is True
+        assert server.sent("Collection.isAlertPolicyReferenced") == {"policyId": 65}
         assert server.sent("Collection.deleteAlertPolicy") == {"policyId": 65, "reassignPolicyId": -1}
         assert server.sent("Collection.searchAlertPolicies")["managedNetworks"] == []
 
     def test_a_policy_still_listed_after_a_delete_is_not_deleted(self, connect):
         client, _ = connect(
             {
+                "Collection.isAlertPolicyReferenced": False,
+                "Collection.deleteAlertPolicy": False,
+                "Collection.searchAlertPolicies": self.listing(65),
+            }
+        )
+        assert client.delete_alert_policy(65) is False
+
+    def test_a_policy_in_use_is_not_deleted_without_a_policy_to_take_its_triggers(self, connect):
+        client, server = connect({"Collection.isAlertPolicyReferenced": True})
+        with pytest.raises(ValueError, match="used by alert triggers"):
+            client.delete_alert_policy(65)
+        assert [method for method, _ in server.requests] == ["Collection.isAlertPolicyReferenced"]
+
+    def test_a_policy_in_use_is_deleted_with_another_to_take_its_triggers(self, connect):
+        client, server = connect(
+            {
+                "Collection.isAlertPolicyReferenced": True,
                 "Collection.deleteAlertPolicy": True,
-                "Collection.searchAlertPolicies": {"policies": [{"policyId": 65, "policyName": "p"}]},
+                "Collection.searchAlertPolicies": self.listing(1, 65),
             }
         )
-        assert client.delete_alert_policy(65, reassign_policy_id=1) is False
+        # The read-back still lists 65 because this fake does not delete; what matters is the request.
+        client.delete_alert_policy(65, reassign_policy_id=1)
+        assert server.sent("Collection.deleteAlertPolicy") == {"policyId": 65, "reassignPolicyId": 1}
+
+    @pytest.mark.parametrize("reassign", [65, 2])
+    def test_a_policy_to_take_the_triggers_must_be_another_that_exists(self, connect, reassign):
+        client, server = connect(
+            {"Collection.isAlertPolicyReferenced": True, "Collection.searchAlertPolicies": self.listing(1, 65)}
+        )
+        with pytest.raises(ValueError):
+            client.delete_alert_policy(65, reassign_policy_id=reassign)
+        assert "Collection.deleteAlertPolicy" not in [method for method, _ in server.requests]
+
+    def test_a_reference_check_with_no_answer_deletes_nothing(self, connect):
+        client, server = connect({"Collection.isAlertPolicyReferenced": None})
+        with pytest.raises(ValueError):
+            client.delete_alert_policy(65)
+        assert "Collection.deleteAlertPolicy" not in [method for method, _ in server.requests]
 
     @pytest.mark.parametrize(
         "answer", [None, {}, {"policies": None}, {"policies": [{}]}, {"policies": [{"policyId": None}, "x"]}]
     )
     def test_a_failed_read_back_raises_rather_than_reading_as_deleted(self, connect, answer):
-        client, _ = connect({"Collection.deleteAlertPolicy": None, "Collection.searchAlertPolicies": answer})
+        client, _ = connect(
+            {
+                "Collection.isAlertPolicyReferenced": False,
+                "Collection.deleteAlertPolicy": True,
+                "Collection.searchAlertPolicies": answer,
+            }
+        )
         with pytest.raises(ValueError):
             client.delete_alert_policy(65)
 

lvi_api_client-0.2.7/VERSION

@@ -1 +0,0 @@
-0.2.7