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

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

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

lvi_api_client-0.2.7/VERSION

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

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

@@ -1840,7 +1840,8 @@ class LogicVeinAPIClient:
                 "summary": str - Incident summary,
                 "severity": str - "INFO", "WARNING", "ERROR", or "CRITICAL",
                 "priority": str - "LOW", "MEDIUM", "HIGH", or "CRITICAL",
-                "status": str - "OPEN", "WORKING", or "CLOSED",
+                "status": str - "OPEN", "RESOLVED" or "DEFERRED" seen on a server; whether
+                    "WORKING" or "CLOSED" exist has not been measured,
                 "resolution": str - "PENDING" or "RESOLVED",
                 "assignee": str - Assigned username (empty string if unassigned),
                 "labels": list[str] - Label tags,
@@ -1875,14 +1876,15 @@ class LogicVeinAPIClient:
     # Incidents
     # =====================================================
 
-    def get_incident_by_id(self, incident_id: int) -> Dict[str, Any]:
+    def get_incident_by_id(self, incident_id: int) -> Optional[Dict[str, Any]]:
         """Get an incident by its ID from the LogicVein server.
 
         Args:
             incident_id (int): The ID of the incident.
 
         Returns:
-            Dict[str, Any]: The incident if it exists, otherwise an empty dictionary.
+            Dict[str, Any]: The incident, or None for an unknown ID, which the server answers with
+            a null result. An empty dictionary only when the server gives no result at all.
         """
         response = self.call("Incidents.getIncidentById", incidentId=incident_id)
 
@@ -2549,6 +2551,8 @@ class LogicVeinAPIClient:
     def delete_managed_network(self, network_name: str) -> bool:
         """Delete a managed network from the LogicVein server.
 
+        An alert policy whose only network this is goes with it.
+
         Args:
             network_name (str): The name of the managed network to delete.
 
@@ -3003,6 +3007,7 @@ class LogicVeinAPIClient:
             commands (str): CLI commands to run, one per line.
             job_name (str): Display name for the job.
             backup_on_completion (bool): If True, LVI backs up the device after the job runs.
+            description (str): The job's description. Empty uses ``job_name``.
 
         Returns:
             Dict[str, Any]: The saved job record (contains ``jobId``), or None on failure.
@@ -3011,7 +3016,7 @@ class LogicVeinAPIClient:
             {
                 "jobId": 0,
                 "jobName": job_name,
-                "description": description or "Job scheduled by ServiceNow",
+                "description": description or job_name,
                 "managedNetworks": [network],
                 "jobType": "Script Tool Job",
                 "subType": "org.ziptie.tools.scripts.commandRunner",
@@ -3052,6 +3057,8 @@ class LogicVeinAPIClient:
             network (str): LVI managed network the device belongs to.
             commands (str): CLI commands to run, one per line.
             job_name (str): Display name for the job in the LVI scheduler.
+            backup_on_completion (bool): If True, LVI backs up the device after the job runs.
+            description (str): The job's description. Empty uses ``job_name``.
 
         Returns:
             Dict[str, Any]: The job execution result dict from LVI (contains ``id``
@@ -3071,7 +3078,7 @@ class LogicVeinAPIClient:
                 "tool": "org.ziptie.tools.scripts.commandRunner",
                 "backupOnCompletion": "true" if backup_on_completion else "false",
             },
-            description=description or "Job scheduled by ServiceNow",
+            description=description or job_name,
         )
 
     # =====================================================
@@ -3645,6 +3652,8 @@ class LogicVeinAPIClient:
         """Get actions configured for an alert policy.
 
         Calls Collection.getActionsForPolicy. Returns the result list directly (not paginated).
+        Settings come back as stored, secrets included: an exec action's ``password`` and a
+        trap action's ``community`` are not masked, and the web UI sends them back unchanged.
         Each action has:
             {
                 "actionId": int - Action ID,
@@ -3674,6 +3683,10 @@ class LogicVeinAPIClient:
         Returns the saved actions with assigned actionIds (new actions use -1 as input id,
         which is replaced with the assigned ID in the response).
 
+        The saved actions **replace** all of the policy's actions; they are not added to them.
+        An empty list does nothing, so it cannot clear a policy's actions. ``username`` is
+        filled in with the caller's when left out.
+
         Each action object should have:
             {
                 "actionId": int - Use -1 for new actions,
@@ -4285,6 +4298,33 @@ class LogicVeinAPIClient:
         Returns:
             List[Dict[str, Any]]: All matching alert policies.
         """
+        return self._search_alert_policies(managed_networks, queries, sort_column, descending, page_size, strict=False)
+
+    def _search_alert_policies(
+        self,
+        managed_networks: List[str],
+        queries: List[str],
+        sort_column: str,
+        descending: bool,
+        page_size: int,
+        strict: bool,
+    ) -> List[Dict[str, Any]]:
+        """Read every page of alert policies.
+
+        Args:
+            managed_networks (List[str]): Networks to search. Empty for all.
+            queries (List[str]): Query filters.
+            sort_column (str): Column to sort by.
+            descending (bool): Sort descending if True.
+            page_size (int): Records per API call.
+            strict (bool): Raise on an answer with no policies list, rather than stopping there.
+
+        Returns:
+            List[Dict[str, Any]]: All matching alert policies.
+
+        Raises:
+            ValueError: If ``strict`` and an answer has no policies list.
+        """
         all_policies: List[Dict[str, Any]] = []
         offset = 0
 
@@ -4303,8 +4343,11 @@ class LogicVeinAPIClient:
             }
             response = self.call("Collection.searchAlertPolicies", **params)
 
-            if response and isinstance(response, dict) and "result" in response and "policies" in response["result"]:
-                batch = response["result"]["policies"]
+            result = response.get("result") if isinstance(response, dict) else None
+            if isinstance(result, dict) and isinstance(result.get("policies"), list):
+                batch = result["policies"]
+            elif strict:
+                raise ValueError("Collection.searchAlertPolicies did not answer with a list of policies")
             else:
                 break
 
@@ -4322,6 +4365,12 @@ class LogicVeinAPIClient:
 
         Calls Collection.saveAlertPolicy. The response mirrors the input policy object.
         Use policyId=-1 (or omit) to create a new policy; provide an existing policyId to update.
+        The result carries the new policy's ID.
+
+        Saving an existing policy **removes all its actions**, although ``actionTypes`` still
+        lists them: save them again with :meth:`save_alert_actions`, as the web UI does. Saving
+        a name that is already in use makes a second policy of that name; check with
+        :meth:`is_alert_policy_name_unique` first.
 
         The policy object has:
             {
@@ -4344,6 +4393,89 @@ class LogicVeinAPIClient:
             return response["result"]
         return None
 
+    def delete_alert_policy(self, policy_id: int, reassign_policy_id: int = -1) -> bool:
+        """Delete an alert policy, with its actions.
+
+        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.
+
+        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.
+
+        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.
+
+        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.
+        """
+        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):
+            raise ValueError("Collection.searchAlertPolicies answered with a policy that has no ID")
+        return policy_id not in ids
+
+    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.
+
+        Args:
+            policy_id (int): The ID of the policy.
+
+        Returns:
+            bool: True if the policy is referenced.
+
+        Raises:
+            ValueError: If the server's answer is not true or false.
+        """
+        response = self.call("Collection.isAlertPolicyReferenced", policyId=policy_id)
+        referenced = response.get("result") if isinstance(response, dict) else None
+        if not isinstance(referenced, bool):
+            raise ValueError(f"Collection.isAlertPolicyReferenced did not answer true or false for {policy_id}")
+        return referenced
+
+    def is_alert_policy_name_unique(
+        self, policy_name: str, managed_networks: List[str], ignore_policy_id: int = -1
+    ) -> bool:
+        """Check whether an alert policy name is free in some networks.
+
+        Calls Collection.isAlertPolicyNameUnique, with the parameters the web UI sends as a
+        name is typed. :meth:`save_alert_policy` does not check: it saves a second policy of
+        a name in use.
+
+        Args:
+            policy_name (str): The name to check.
+            managed_networks (List[str]): The networks to check it in.
+            ignore_policy_id (int): A policy to leave out, such as the one being renamed. -1 for none.
+
+        Returns:
+            bool: True if the name is free.
+
+        Raises:
+            ValueError: If the server's answer is not true or false.
+        """
+        response = self.call(
+            "Collection.isAlertPolicyNameUnique",
+            policyName=policy_name,
+            managedNetworks=managed_networks,
+            ignorePolicyId=ignore_policy_id,
+        )
+        unique = response.get("result") if isinstance(response, dict) else None
+        if not isinstance(unique, bool):
+            raise ValueError(f"Collection.isAlertPolicyNameUnique did not answer true or false for {policy_name}")
+        return unique
+
     # =====================================================
     # Maps / Topology
     # =====================================================
@@ -4620,27 +4752,32 @@ class LogicVeinAPIClient:
         where ``recordId`` is the ``id`` field from a ``getExecutionDetails``
         record.
 
+        The server finds the output by ``recordId`` alone: a record of another
+        execution comes back as long as the execution ID exists.
+
         Args:
             execution_id: The execution ID (``executionId`` from the job result).
             record_id: The per-device record ID (``id`` from ``getExecutionDetails``).
 
         Returns:
-            The raw output text, or an empty string if the request fails.
+            The raw output text.
+
+        Raises:
+            requests.HTTPError: If the server refuses the request, for example
+                401 for a bad token, 404 for an unknown execution or 500 for a
+                malformed ID.
+            ValueError: If the server has no record with that ID. It answers
+                200 with an empty body and no content type then, which is not
+                an empty output: a Command Runner output holds at least the
+                command and the prompt.
         """
         url = f"https://{self.host}/servlet/pluginDetail"
         params = {"executionId": execution_id, "recordId": record_id}
-        try:
-            response = self.lvi_client.get(url, params=params, timeout=self.timeout)
-            response.raise_for_status()
-            return response.text
-        except Exception as exc:
-            logger.warning(
-                "get_execution_output failed for executionId=%s recordId=%s: %s",
-                execution_id,
-                record_id,
-                exc,
-            )
-            return ""
+        response = self.lvi_client.get(url, params=params, timeout=self.timeout)
+        response.raise_for_status()
+        if not response.content and not response.headers.get("Content-Type"):
+            raise ValueError(f"No output record {record_id} in execution {execution_id}")
+        return response.text
 
     # =====================================================
     # ZeroTouch

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

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

{lvi_api_client-0.2.4 → lvi_api_client-0.2.7}/src/lvi_api_client.egg-info/SOURCES.txt

@@ -9,5 +9,6 @@ src/lvi_api_client.egg-info/SOURCES.txt
 src/lvi_api_client.egg-info/dependency_links.txt
 src/lvi_api_client.egg-info/requires.txt
 src/lvi_api_client.egg-info/top_level.txt
+tests/test_check_version_bump.py
 tests/test_lvi_api_client.py
 tests/test_server_request_shapes.py

lvi_api_client-0.2.7/tests/test_check_version_bump.py

@@ -0,0 +1,61 @@
+"""Tests for scripts/ci/check_version_bump.py."""
+
+import importlib.util
+from pathlib import Path
+
+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)
+check = importlib.util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(check)
+
+LOG = "# Changelog\n\n## [0.2.7] - 2026-11-08\n\n### Fixed\n- Something.\n\n## [0.2.6] - 2026-11-07\n"
+
+
+def test_a_heading_for_the_version_passes():
+    assert check.changelog_problem(LOG, "0.2.7") == ""
+
+
+@pytest.mark.parametrize(
+    "changelog",
+    [
+        "## [Unreleased]\n\n### Fixed\n- Something.\n\n## [0.2.6] - 2026-11-07\n",
+        "Fixed in [0.2.7], see below.\n## [0.2.6]\n",
+        "## [0.2.70] - 2026-11-08\n",
+    ],
+    ids=["only unreleased", "not a heading", "another version"],
+)
+def test_no_heading_for_the_version_fails(changelog):
+    assert "no '## [0.2.7]' heading" in check.changelog_problem(changelog, "0.2.7")
+
+
+def _run(monkeypatch, tmp_path, changed, version, changelog, base_version="0.2.6"):
+    (tmp_path / "VERSION").write_text(version + "\n")
+    (tmp_path / "CHANGELOG.md").write_text(changelog)
+    monkeypatch.setattr(check, "REPO_ROOT", tmp_path)
+
+    def git(*args):
+        return "\n".join(changed) if args[0] == "diff" else base_version + "\n"
+
+    monkeypatch.setattr(check, "_git", git)
+    monkeypatch.setattr("sys.argv", ["check_version_bump.py", "--base", "abc123"])
+    return check.main()
+
+
+def test_a_bump_with_entries_left_under_unreleased_fails(monkeypatch, tmp_path, capsys):
+    changelog = "## [Unreleased]\n\n### Fixed\n- Something.\n"
+    assert _run(monkeypatch, tmp_path, ["src/x.py", "VERSION", "CHANGELOG.md"], "0.2.7", changelog) == 1
+    assert "no '## [0.2.7]' heading" in capsys.readouterr().out
+
+
+def test_a_bump_without_a_src_change_still_needs_the_heading(monkeypatch, tmp_path):
+    assert _run(monkeypatch, tmp_path, ["VERSION"], "0.2.7", "## [0.2.6]\n") == 1
+
+
+def test_a_bump_with_its_heading_passes(monkeypatch, tmp_path):
+    assert _run(monkeypatch, tmp_path, ["src/x.py", "VERSION", "CHANGELOG.md"], "0.2.7", LOG) == 0
+
+
+def test_a_docs_change_needs_nothing(monkeypatch, tmp_path):
+    assert _run(monkeypatch, tmp_path, ["CHANGELOG.md", "README.md"], "0.2.6", "## [Unreleased]\n") == 0

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

@@ -5048,7 +5048,7 @@ class TestCreateCommandRunnerJob:
 
 
 class TestGetExecutionOutput:
-    """Tests for get_execution_output (lines 3641-3674): success and exception paths."""
+    """Tests for get_execution_output: the text on success, and an error for every failure."""
 
     @pytest.fixture
     def client(self, monkeypatch):
@@ -5057,39 +5057,50 @@ class TestGetExecutionOutput:
         with patch("src.logicvein.lvi_api_client.requests.Session"):
             return LogicVeinAPIClient()
 
+    @staticmethod
+    def answer(status, body=b"", content_type=None):
+        """A real requests.Response, shaped like the lab server's answers (issue #6)."""
+        response = requests.Response()
+        response.status_code = status
+        response._content = body
+        response.encoding = "utf-8"
+        if content_type:
+            response.headers["Content-Type"] = content_type
+        response.url = "https://test.example.com/servlet/pluginDetail"
+        return response
+
     def test_get_execution_output_success(self, client):
-        """get_execution_output returns response text on success."""
-        mock_get_response = Mock()
-        mock_get_response.raise_for_status = Mock()
-        mock_get_response.text = "show version output\nCisco IOS Version 15.1"
-        client.lvi_client.get = Mock(return_value=mock_get_response)
+        """get_execution_output returns the text, and asks for the execution and record."""
+        output = b"show clock\r\n16:57:34.919 UTC Sat Nov 7 2026\r\nc1800#"
+        client.lvi_client.get = Mock(return_value=self.answer(200, output, "text/plain;charset=utf-8"))
 
         result = client.get_execution_output(execution_id=42, record_id=7)
 
-        assert result == "show version output\nCisco IOS Version 15.1"
-        client.lvi_client.get.assert_called_once()
-        call_args = client.lvi_client.get.call_args
-        assert "executionId" in call_args.kwargs["params"]
-        assert call_args.kwargs["params"]["executionId"] == 42
-        assert call_args.kwargs["params"]["recordId"] == 7
+        assert result == output.decode()
+        assert client.lvi_client.get.call_args.kwargs["params"] == {"executionId": 42, "recordId": 7}
 
-    def test_get_execution_output_http_error_returns_empty_string(self, client):
-        """get_execution_output returns '' when raise_for_status raises."""
-        mock_get_response = Mock()
-        mock_get_response.raise_for_status.side_effect = requests.HTTPError("403 Forbidden")
-        client.lvi_client.get = Mock(return_value=mock_get_response)
+    @pytest.mark.parametrize("status", [401, 404, 500])
+    def test_get_execution_output_http_error_raises(self, client, status):
+        """A refused read raises instead of reading as an empty output (issue #6)."""
+        page = b"<!doctype html><html></html>"
+        client.lvi_client.get = Mock(return_value=self.answer(status, page, "text/html;charset=utf-8"))
 
-        result = client.get_execution_output(execution_id=42, record_id=7)
+        with pytest.raises(requests.HTTPError):
+            client.get_execution_output(execution_id=42, record_id=7)
 
-        assert result == ""
+    def test_get_execution_output_unknown_record_raises(self, client):
+        """The server answers an unknown record with 200, no body and no content type (issue #6)."""
+        client.lvi_client.get = Mock(return_value=self.answer(200))
 
-    def test_get_execution_output_connection_error_returns_empty_string(self, client):
-        """get_execution_output returns '' when a connection exception is raised."""
-        client.lvi_client.get = Mock(side_effect=requests.exceptions.ConnectionError("refused"))
+        with pytest.raises(ValueError, match="No output record 7 in execution 42"):
+            client.get_execution_output(execution_id=42, record_id=7)
 
-        result = client.get_execution_output(execution_id=99, record_id=1)
+    def test_get_execution_output_connection_error_raises(self, client):
+        """A transport failure propagates instead of reading as an empty output (issue #6)."""
+        client.lvi_client.get = Mock(side_effect=requests.exceptions.ConnectionError("refused"))
 
-        assert result == ""
+        with pytest.raises(requests.exceptions.ConnectionError):
+            client.get_execution_output(execution_id=99, record_id=1)
 
 
 class TestRunCommandRunnerJob:
@@ -5121,6 +5132,27 @@ class TestRunCommandRunnerJob:
         assert result["executionId"] == "exec-77"
         client.lvi_client.post.assert_called_once()
 
+    def test_run_command_runner_job_describes_the_job_by_its_name(self, client, mock_response):
+        """An empty description uses the job name, not "Job scheduled by ServiceNow" (issue #5)."""
+        mock_response.json.return_value = {"jsonrpc": "2.0", "id": "t", "result": {"executionId": 1}}
+        client.lvi_client.post = Mock(return_value=mock_response)
+
+        client.run_command_runner_job("10.1.1.1", "Default", "show version", job_name="NTP check")
+
+        body = json.loads(client.lvi_client.post.call_args.kwargs["data"])
+        assert body["method"] == "Scheduler.runNow"
+        assert body["params"]["jobData"]["description"] == "NTP check"
+
+    def test_run_command_runner_job_keeps_a_given_description(self, client, mock_response):
+        """A description the caller gives is sent as it is."""
+        mock_response.json.return_value = {"jsonrpc": "2.0", "id": "t", "result": {"executionId": 1}}
+        client.lvi_client.post = Mock(return_value=mock_response)
+
+        client.run_command_runner_job("10.1.1.1", "Default", "show version", description="Change 42")
+
+        body = json.loads(client.lvi_client.post.call_args.kwargs["data"])
+        assert body["params"]["jobData"]["description"] == "Change 42"
+
     def test_run_command_runner_job_with_backup(self, client, mock_response):
         """run_command_runner_job passes backup_on_completion=True in job parameters."""
         mock_response.json.return_value = {
@@ -5201,15 +5233,15 @@ class TestCreateCommandRunnerJobBackupAndDescription:
         body = json.loads(client.lvi_client.post.call_args.kwargs["data"])
         assert body["params"]["jobData"]["description"] == "My custom description"
 
-    def test_empty_description_defaults_to_service_now_string(self, client, mock_response):
-        """create_command_runner_job defaults description when empty string passed."""
+    def test_empty_description_defaults_to_the_job_name(self, client, mock_response):
+        """create_command_runner_job describes the job by its name, not by any one caller (issue #5)."""
         mock_response.json.return_value = {"jsonrpc": "2.0", "id": "t", "result": {"jobId": 12}}
         client.lvi_client.post = Mock(return_value=mock_response)
 
-        client.create_command_runner_job("10.1.1.1", "Default", "show version", description="")
+        client.create_command_runner_job("10.1.1.1", "Default", "show version", job_name="NTP check", description="")
 
         body = json.loads(client.lvi_client.post.call_args.kwargs["data"])
-        assert body["params"]["jobData"]["description"] == "Job scheduled by ServiceNow"
+        assert body["params"]["jobData"]["description"] == "NTP check"
 
 
 class TestRunJobNowSubTypeBranch:

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

@@ -620,3 +620,70 @@ class TestDeployingASet:
         with pytest.raises(ValueError):
             client.associate_monitor_set(2, queries)
         assert server.requests == []
+
+
+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):
+        client, server = connect(
+            {
+                "Collection.deleteAlertPolicy": None,
+                "Collection.searchAlertPolicies": {"policies": [{"policyId": 1, "policyName": "kept"}]},
+            }
+        )
+        assert client.delete_alert_policy(65) is True
+        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.deleteAlertPolicy": True,
+                "Collection.searchAlertPolicies": {"policies": [{"policyId": 65, "policyName": "p"}]},
+            }
+        )
+        assert client.delete_alert_policy(65, reassign_policy_id=1) is False
+
+    @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})
+        with pytest.raises(ValueError):
+            client.delete_alert_policy(65)
+
+    def test_a_failed_search_still_reads_as_no_policies(self, connect):
+        client, _ = connect({"Collection.searchAlertPolicies": None})
+        assert client.search_alert_policies() == []
+
+    @pytest.mark.parametrize("answer", [True, False])
+    def test_a_reference_check_sends_the_id_and_returns_the_answer(self, connect, answer):
+        client, server = connect({"Collection.isAlertPolicyReferenced": answer})
+        assert client.is_alert_policy_referenced(27) is answer
+        assert server.sent("Collection.isAlertPolicyReferenced") == {"policyId": 27}
+
+    def test_a_reference_check_with_no_answer_raises_rather_than_reading_as_unreferenced(self, connect):
+        client, _ = connect({"Collection.isAlertPolicyReferenced": None})
+        with pytest.raises(ValueError):
+            client.is_alert_policy_referenced(27)
+
+    @pytest.mark.parametrize("answer", [True, False])
+    def test_a_name_check_sends_what_the_ui_sends_and_returns_the_answer(self, connect, answer):
+        client, server = connect({"Collection.isAlertPolicyNameUnique": answer})
+        assert client.is_alert_policy_name_unique("p1", ["Default"], ignore_policy_id=1) is answer
+        assert server.sent("Collection.isAlertPolicyNameUnique") == {
+            "policyName": "p1",
+            "managedNetworks": ["Default"],
+            "ignorePolicyId": 1,
+        }
+
+    def test_a_name_check_ignores_no_policy_by_default(self, connect):
+        client, server = connect({"Collection.isAlertPolicyNameUnique": True})
+        client.is_alert_policy_name_unique("p1", ["Default"])
+        assert server.sent("Collection.isAlertPolicyNameUnique")["ignorePolicyId"] == -1
+
+    def test_a_name_check_with_no_answer_raises_rather_than_reading_as_taken(self, connect):
+        client, _ = connect({"Collection.isAlertPolicyNameUnique": None})
+        with pytest.raises(ValueError):
+            client.is_alert_policy_name_unique("p1", ["Default"])

lvi_api_client-0.2.4/VERSION

@@ -1 +0,0 @@
-0.2.4