@ngocsangairvds/vsaf 3.1.27 → 3.2.1

package/tools/vds-scripts/confluence_orchestrator/tests/test_history.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import Mock
+
+import pytest
+from confluence_orchestrator.cli import app
+from confluence_orchestrator.config import ConfluenceSettings
+from confluence_orchestrator.http import ConfluenceClient
+from typer.testing import CliRunner
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def mock_settings(monkeypatch: pytest.MonkeyPatch) -> None:
+    def fake_load_settings(strict: bool = False) -> ConfluenceSettings:
+        return ConfluenceSettings.model_validate(
+            {
+                "VDS_USERNAME": "user",
+                "VDS_PASSWORD": "pass",
+                "INTERNAL_CONFLUENCE_TOKEN": "token-int",
+                "EXTERNAL_CONFLUENCE_TOKEN": "token-ext",
+            }
+        )
+
+    monkeypatch.setattr("confluence_orchestrator.cli.load_settings", fake_load_settings)
+
+
+def _build_fake_client() -> tuple[ConfluenceClient, Mock]:
+    inner = Mock()
+    client = ConfluenceClient.__new__(ConfluenceClient)  # type: ignore[call-arg]
+    client._client = inner  # type: ignore[attr-defined]
+    client._log = Mock()
+    client._is_cloud = False  # type: ignore[attr-defined]
+    client._with_retry = lambda operation, _: operation()  # type: ignore[assignment]
+    return client, inner
+
+
+# ---------------------------------------------------------------------------
+# Client method coverage
+# ---------------------------------------------------------------------------
+
+
+def test_client_history_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.history.return_value = {"latest": True, "results": [{"number": 1, "when": "2025-01-01"}]}
+
+    result = client.history("123")
+
+    assert "latest" in result
+    inner.history.assert_called_once_with("123")
+
+
+def test_client_get_content_history_by_version_number_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.get_content_history_by_version_number.return_value = {"id": "123", "version": 2, "title": "Version 2"}
+
+    result = client.get_content_history_by_version_number("123", 2)
+
+    assert result["version"] == 2
+    inner.get_content_history_by_version_number.assert_called_once_with("123", 2)
+
+
+def test_client_remove_content_history_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.remove_content_history.return_value = None
+
+    result = client.remove_content_history("123", 2)
+
+    assert result is None
+    inner.remove_content_history.assert_called_once_with("123", 2)
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummyHistoryClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+
+    def history(self, page_id: str) -> dict[str, Any]:
+        self.calls.append(("history", (page_id,), {}))
+        return {"latest": True, "results": [{"number": 1}]}
+
+    def get_content_history_by_version_number(self, page_id: str, version: int) -> dict[str, Any]:
+        self.calls.append(("get_content_history_by_version_number", (page_id, version), {}))
+        return {"id": page_id, "version": version}
+
+    def remove_content_history(self, page_id: str, version: int) -> None:
+        self.calls.append(("remove_content_history", (page_id, version), {}))
+
+
+def test_cli_history_get_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "get", "--page-id", "123"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "history"
+
+
+def test_cli_history_get_requires_page_id(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "get"])
+
+    assert result.exit_code != 0
+    assert "--page-id required" in result.stdout or "--page-id required" in result.stderr
+
+
+def test_cli_history_version_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "version", "--page-id", "123", "--version", "2"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert "2" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_content_history_by_version_number"
+    assert client.calls[0][1][1] == 2
+
+
+def test_cli_history_version_requires_page_id(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "version", "--version", "2"])
+
+    assert result.exit_code != 0
+    assert "--page-id required" in result.stdout or "--page-id required" in result.stderr
+
+
+def test_cli_history_version_requires_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "version", "--page-id", "123"])
+
+    assert result.exit_code != 0
+    assert "--version required" in result.stdout or "--version required" in result.stderr
+
+
+def test_cli_history_remove_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "remove", "--page-id", "123", "--version", "2", "--yes"])
+
+    assert result.exit_code == 0
+    assert "removed" in result.stdout
+    assert "experimental" in result.stderr
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "remove_content_history"
+
+
+def test_cli_history_remove_requires_yes(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "remove", "--page-id", "123", "--version", "2"])
+
+    assert result.exit_code != 0
+    assert "--yes required" in result.stdout or "--yes required" in result.stderr
+    assert "experimental" in result.stdout or "experimental" in result.stderr
+
+
+def test_cli_history_remove_requires_page_id(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "remove", "--version", "2", "--yes"])
+
+    assert result.exit_code != 0
+    assert "--page-id required" in result.stdout or "--page-id required" in result.stderr
+
+
+def test_cli_history_remove_requires_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "remove", "--page-id", "123", "--yes"])
+
+    assert result.exit_code != 0
+    assert "--version required" in result.stdout or "--version required" in result.stderr
+
+
+def test_cli_history_invalid_action(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyHistoryClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["history", "invalid"])
+
+    assert result.exit_code != 0
+    assert "Unknown action" in result.stdout or "Unknown action" in result.stderr
+

package/tools/vds-scripts/confluence_orchestrator/tests/test_http.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import httpx
+import pytest
+from confluence_orchestrator.config import ConfluenceSettings
+from confluence_orchestrator.errors import (
+    ConfluenceAuthError,
+    ConfluenceClientError,
+    ConfluenceConflictError,
+)
+from confluence_orchestrator.http import ConfluenceClient, ConfluenceHttpClient, RetryConfig
+
+
+@pytest.fixture()
+def base_settings() -> ConfluenceSettings:
+    return ConfluenceSettings.model_validate(
+        {
+            "VDS_USERNAME": "user",
+            "VDS_PASSWORD": "pass",
+            "INTERNAL_CONFLUENCE_TOKEN": "token-int",
+            "EXTERNAL_CONFLUENCE_TOKEN": "token-ext",
+        }
+    )
+
+
+def make_client(settings: ConfluenceSettings, handler: httpx.MockTransport) -> ConfluenceHttpClient:
+    client = httpx.Client(
+        base_url=str(settings.internal_url),
+        transport=handler,
+        headers={"Authorization": "Bearer token-int", "Accept": "application/json"},
+    )
+    return ConfluenceHttpClient(settings, client=client, retry_config=RetryConfig(max_attempts=3, backoff_factor=0.01, max_wait=0.05))
+
+
+def test_successful_request(monkeypatch: pytest.MonkeyPatch, base_settings: ConfluenceSettings) -> None:
+    attempts = {"count": 0}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        attempts["count"] += 1
+        return httpx.Response(200, json={"ok": True})
+
+    client = make_client(base_settings, httpx.MockTransport(handler))
+    response = client.request("GET", "/rest/api/content/123")
+    assert response.status_code == 200
+    assert attempts["count"] == 1
+
+
+def test_rate_limit_retry(monkeypatch: pytest.MonkeyPatch, base_settings: ConfluenceSettings) -> None:
+    attempts = {"count": 0}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        attempts["count"] += 1
+        if attempts["count"] == 1:
+            return httpx.Response(429, headers={"Retry-After": "0.01"})
+        return httpx.Response(200, json={"ok": True})
+
+    client = make_client(base_settings, httpx.MockTransport(handler))
+    response = client.request("GET", "/rest/api/content/123")
+    assert response.status_code == 200
+    assert attempts["count"] == 2
+
+
+def test_conflict_raises(base_settings: ConfluenceSettings) -> None:
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(409)
+
+    client = make_client(base_settings, httpx.MockTransport(handler))
+
+    with pytest.raises(ConfluenceConflictError):
+        client.request("POST", "/rest/api/content/123")
+
+
+def test_missing_token_raises(base_settings: ConfluenceSettings) -> None:
+    stripped_settings = base_settings.model_copy(update={"internal_token": None})
+    with pytest.raises(ConfluenceAuthError):
+        ConfluenceHttpClient(stripped_settings)
+
+
+def _make_stub_confluence_client() -> ConfluenceClient:
+    client = ConfluenceClient.__new__(ConfluenceClient)
+    client._log = MagicMock()
+    client._client = MagicMock()
+    client._settings = MagicMock()
+    client._server = "internal"
+    return client
+
+
+def test_delete_attachment_all_versions(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = _make_stub_confluence_client()
+    client._client.get_attachment_history.return_value = [{"number": 1}, {"number": 2}]
+    client._client.get_attachments.return_value = {"results": [{"id": "att-1", "title": "file.pdf"}]}
+
+    client.delete_attachment_by_id("123", "att-1")
+
+    client._client.delete_attachment_by_id.assert_any_call("att-1", 2)
+    client._client.delete_attachment_by_id.assert_any_call("att-1", 1)
+    assert client._client.delete_attachment_by_id.call_count == 2
+
+
+def test_delete_attachment_specific_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = _make_stub_confluence_client()
+    client._client.get_attachment_history.return_value = [{"number": 1}, {"number": 2}]
+
+    client.delete_attachment_by_id("123", "att-1", version=1)
+
+    client._client.delete_attachment_by_id.assert_called_once_with("att-1", 1)
+
+
+def test_delete_attachment_requires_version_when_history_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = _make_stub_confluence_client()
+    client._client.get_attachment_history.return_value = []
+    client._client.get_attachments.return_value = {"results": []}
+
+    with pytest.raises(ConfluenceClientError):
+        client.delete_attachment_by_id("123", "att-1")

package/tools/vds-scripts/confluence_orchestrator/tests/test_orchestration.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any
+
+from confluence_orchestrator.orchestration import BatchRunner, WebhookClient
+
+
+class FakeClient:
+    def __init__(self, responses: list[dict[str, Any]]) -> None:
+        self.responses = responses
+        self.calls = 0
+
+    def search_cql(self, *_, **kwargs) -> dict[str, Any]:  # noqa: ANN401
+        limit = kwargs.get("limit")
+        if self.calls < len(self.responses):
+            payload = dict(self.responses[self.calls])
+            if limit is not None:
+                payload["results"] = payload["results"][:limit]
+        else:
+            payload = {"results": [], "start": 0, "limit": 0}
+        self.calls += 1
+        return payload
+
+    def request(self, method: str, path: str, **kwargs: Any):  # noqa: ANN401
+        return FakeResponse({"method": method, "path": path, **kwargs})
+
+
+class FakeResponse:
+    def __init__(self, payload: dict[str, Any]) -> None:
+        self._payload = payload
+
+    def json(self) -> dict[str, Any]:
+        return self._payload
+
+
+def test_batch_runner_scan_returns_results() -> None:
+    client = FakeClient(
+        [
+            {
+                "results": [
+                    {"id": "10"},
+                    {"id": "11"},
+                ],
+                "start": 0,
+                "limit": 2,
+            }
+        ]
+    )
+
+    runner = BatchRunner(client)  # type: ignore[arg-type]
+    results = list(runner.scan("type=page", limit=2))
+
+    assert len(results) == 2
+    assert runner.last_metrics is not None
+    assert runner.last_metrics.pages_processed == 2
+
+
+def test_batch_runner_snapshot() -> None:
+    client = FakeClient([
+        {
+            "results": [{"id": "10"}],
+            "start": 0,
+            "limit": 1,
+        }
+    ])
+
+    runner = BatchRunner(client)  # type: ignore[arg-type]
+    payload = runner.snapshot("type=page", limit=1)
+
+    assert payload["count"] == 1
+    assert payload["results"][0]["id"] == "10"
+
+
+def test_webhook_client_creates_lists_and_deletes() -> None:
+    events: list[dict[str, Any]] = []
+
+    class RecordingHttp:
+        def request(self, method: str, path: str, **kwargs: Any):  # noqa: ANN401
+            events.append({"method": method, "path": path, **kwargs})
+            if method == "GET":
+                return FakeResponse([{"id": "1"}])
+            return FakeResponse({"id": "1"})
+
+    client = WebhookClient(RecordingHttp())  # type: ignore[arg-type]
+    client.create(name="Notify", url="https://example", events=["page_created"])
+    client.list()
+    client.delete("1")
+
+    assert events[0]["method"] == "POST"
+    assert events[1]["method"] == "GET"
+    assert events[2]["path"].endswith("/1")

package/tools/vds-scripts/confluence_orchestrator/tests/test_reporting.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from confluence_orchestrator.reporting import RunSummary, write_reports
+
+
+def test_write_reports_creates_json_and_markdown(tmp_path: Path) -> None:
+    summary = RunSummary(
+        command="templates",
+        args=["--server", "internal"],
+        server="internal",
+        exit_code=0,
+        duration_ms=1200,
+        started_at=datetime(2025, 11, 4, 10, 0, 0, tzinfo=datetime.UTC),
+        finished_at=datetime(2025, 11, 4, 10, 0, 2, tzinfo=datetime.UTC),
+    )
+
+    json_path = write_reports(summary, base_dir=tmp_path, include_markdown=True)
+    assert json_path.exists()
+    md_path = json_path.with_suffix(".md")
+    assert md_path.exists()
+    assert "✅ Success" in md_path.read_text()

package/tools/vds-scripts/confluence_orchestrator/tests/test_search_cql.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from confluence_orchestrator.content import ContentClient
+
+
+class DummyClient:
+    def __init__(self) -> None:
+        self.calls: list[dict[str, Any]] = []
+
+    def search_cql(self, cql: str, limit: int = 25, start: int = 0, expand: Any = None, **kwargs: Any) -> dict[str, Any]:  # noqa: ANN401
+        self.calls.append({"cql": cql, "limit": limit, "start": start, "expand": expand})
+        return {
+            "results": [
+                {"id": "1", "type": "page", "title": "First"},
+                {"id": "2", "type": "page", "title": "Second"},
+            ],
+            "start": start,
+            "limit": limit,
+        }
+
+
+@pytest.fixture()
+def content_client() -> ContentClient:
+    return ContentClient(DummyClient())
+
+
+def test_search_cql_basic(content_client: ContentClient) -> None:
+    payload = content_client.search_cql("type=page", limit=2, start=0)
+    assert payload["limit"] == 2
+    assert len(payload["results"]) == 2
+    assert payload["results"][0]["title"] == "First"