@ngocsangairvds/vsaf 3.1.27 → 3.2.2

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

@@ -0,0 +1,223 @@
+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.errors import ConfluenceClientError
+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(cloud: bool = False) -> 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 = cloud  # type: ignore[attr-defined]
+    client._with_retry = lambda operation, _: operation()  # type: ignore[assignment]
+    return client, inner
+
+
+# ---------------------------------------------------------------------------
+# Client method coverage
+# ---------------------------------------------------------------------------
+
+
+def test_client_get_draft_page_by_id_server_mode_invokes_sdk() -> None:
+    client, inner = _build_fake_client(cloud=False)
+    inner.get_draft_page_by_id.return_value = {"id": "123", "title": "Draft Page"}
+
+    result = client.get_draft_page_by_id("123")
+
+    assert result["id"] == "123"
+    inner.get_draft_page_by_id.assert_called_once_with("123")
+
+
+def test_client_get_draft_page_by_id_cloud_mode_raises_error() -> None:
+    client, inner = _build_fake_client(cloud=True)
+
+    with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+        client.get_draft_page_by_id("123")
+    inner.get_draft_page_by_id.assert_not_called()
+
+
+def test_client_get_all_draft_pages_from_space_server_mode_invokes_sdk() -> None:
+    client, inner = _build_fake_client(cloud=False)
+    inner.get_all_draft_pages_from_space.return_value = [{"id": "1", "title": "Draft 1"}, {"id": "2", "title": "Draft 2"}]
+
+    result = client.get_all_draft_pages_from_space("ABC", limit=50)
+
+    assert len(result) == 2
+    inner.get_all_draft_pages_from_space.assert_called_once_with("ABC", limit=50)
+
+
+def test_client_get_all_draft_pages_from_space_cloud_mode_raises_error() -> None:
+    client, inner = _build_fake_client(cloud=True)
+
+    with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+        client.get_all_draft_pages_from_space("ABC")
+    inner.get_all_draft_pages_from_space.assert_not_called()
+
+
+def test_client_remove_page_as_draft_server_mode_invokes_sdk() -> None:
+    client, inner = _build_fake_client(cloud=False)
+    inner.remove_page_as_draft.return_value = None
+
+    result = client.remove_page_as_draft("123")
+
+    assert result is None
+    inner.remove_page_as_draft.assert_called_once_with("123")
+
+
+def test_client_remove_page_as_draft_cloud_mode_raises_error() -> None:
+    client, inner = _build_fake_client(cloud=True)
+
+    with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+        client.remove_page_as_draft("123")
+    inner.remove_page_as_draft.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummyDraftClient:
+    def __init__(self, cloud: bool = False) -> None:
+        self.calls: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+        self._is_cloud = cloud  # type: ignore[attr-defined]
+
+    def get_draft_page_by_id(self, page_id: str) -> dict[str, Any]:
+        if self._is_cloud:
+            raise ConfluenceClientError("Server-only feature")
+        self.calls.append(("get_draft_page_by_id", (page_id,), {}))
+        return {"id": page_id, "title": "Draft Page"}
+
+    def get_all_draft_pages_from_space(self, space_key: str, limit: int = 25) -> list[dict[str, Any]]:
+        if self._is_cloud:
+            raise ConfluenceClientError("Server-only feature")
+        self.calls.append(("get_all_draft_pages_from_space", (space_key,), {"limit": limit}))
+        return [{"id": "1", "title": "Draft 1"}]
+
+    def remove_page_as_draft(self, page_id: str) -> None:
+        if self._is_cloud:
+            raise ConfluenceClientError("Server-only feature")
+        self.calls.append(("remove_page_as_draft", (page_id,), {}))
+
+
+def test_cli_draft_get_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "get", "--page-id", "123"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_draft_page_by_id"
+
+
+def test_cli_draft_get_requires_page_id(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "get"])
+
+    assert result.exit_code != 0
+    assert "--page-id required" in result.stdout or "--page-id required" in result.stderr
+
+
+def test_cli_draft_list_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "list", "--space-key", "ABC", "--limit", "50"])
+
+    assert result.exit_code == 0
+    assert "ABC" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_all_draft_pages_from_space"
+    assert client.calls[0][2]["limit"] == 50
+
+
+def test_cli_draft_list_requires_space_key(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "list"])
+
+    assert result.exit_code != 0
+    assert "--space-key required" in result.stdout or "--space-key required" in result.stderr
+
+
+def test_cli_draft_remove_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "remove", "--page-id", "123", "--yes"])
+
+    assert result.exit_code == 0
+    assert "removed" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "remove_page_as_draft"
+
+
+def test_cli_draft_remove_requires_yes(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "remove", "--page-id", "123"])
+
+    assert result.exit_code != 0
+    assert "--yes required" in result.stdout or "--yes required" in result.stderr
+
+
+def test_cli_draft_remove_requires_page_id(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "remove", "--yes"])
+
+    assert result.exit_code != 0
+    assert "--page-id required" in result.stdout or "--page-id required" in result.stderr
+
+
+def test_cli_draft_cloud_mode_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=True)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "get", "--page-id", "123"])
+
+    assert result.exit_code != 0
+    assert "Server-only" in result.stderr or "Server-only" in result.stdout
+
+
+def test_cli_draft_invalid_action(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyDraftClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["draft", "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_eventing.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from confluence_orchestrator.eventing import Poller
+
+
+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):
+            resp = self._responses[self.calls]
+            payload = dict(resp)
+            if limit is not None and "results" in payload:
+                payload["results"] = payload["results"][:limit]
+        else:
+            payload = {"results": [], "start": 0, "limit": 0}
+        self.calls += 1
+        return payload
+
+
+def test_poller_updates_cursor(tmp_path: Path) -> None:
+    client = FakeClient(
+        [
+            {
+                "results": [
+                    {"id": "10", "version": {"when": "2024-01-02T00:00:00Z"}},
+                    {"id": "11", "version": {"when": "2024-01-03T00:00:00Z"}},
+                ],
+                "start": 0,
+                "limit": 25,
+            }
+        ]
+    )
+
+    poller = Poller(client)  # type: ignore[arg-type]
+    state_file = tmp_path / "cursor.json"
+    count = poller.poll_once(base_cql="type=page", state_file=state_file, expand=["version"], out_jsonl=tmp_path / "out.jsonl")
+
+    assert count == 2
+    data = state_file.read_text()
+    assert "2024-01-03T00:00:00Z" in data
+    jsonl_contents = (tmp_path / "out.jsonl").read_text().strip().splitlines()
+    assert len(jsonl_contents) == 2
+
+
+def test_poller_limits_results(tmp_path: Path) -> None:
+    client = FakeClient(
+        [
+            {
+                "results": [
+                    {"id": "10", "version": {"when": "2024-01-02T00:00:00Z"}},
+                    {"id": "11", "version": {"when": "2024-01-03T00:00:00Z"}},
+                ],
+                "start": 0,
+                "limit": 25,
+            }
+        ]
+    )
+
+    poller = Poller(client)  # type: ignore[arg-type]
+    state_file = tmp_path / "cursor.json"
+    count = poller.poll_once(base_cql="type=page", state_file=state_file, max_results=1)
+
+    assert count == 1
+    assert "2024-01-02T00:00:00Z" in state_file.read_text()

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

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from confluence_orchestrator.eventing import Poller
+
+
+class SingleRunClient:
+    def __init__(self, results: list[dict[str, Any]]) -> None:
+        self._results = results
+        self.calls = 0
+
+    def search_cql(self, *_, **kwargs) -> dict[str, Any]:  # noqa: ANN401
+        limit = kwargs.get("limit")
+        if self.calls == 0:
+            payload = {"results": self._results, "start": 0, "limit": len(self._results)}
+            if limit is not None:
+                payload["results"] = self._results[:limit]
+        else:
+            payload = {"results": [], "start": 0, "limit": 0}
+        self.calls += 1
+        return payload
+
+
+def test_poller_persists_state_across_runs(tmp_path: Path) -> None:
+    state_file = tmp_path / "cursor.json"
+
+    poller = Poller(SingleRunClient([{ "id": "10", "version": {"when": "2024-01-02T00:00:00Z"}}]))  # type: ignore[arg-type]
+    poller.poll_once(base_cql="type=page", state_file=state_file)
+    assert "2024-01-02T00:00:00Z" in state_file.read_text()
+
+    poller = Poller(SingleRunClient([{ "id": "11", "version": {"when": "2024-01-04T00:00:00Z"}}]))  # type: ignore[arg-type]
+    poller.poll_once(base_cql="type=page", state_file=state_file)
+    contents = state_file.read_text()
+    assert "2024-01-04T00:00:00Z" in contents
+    assert "\"10\"" in contents and "\"11\"" in contents

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

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from confluence_orchestrator.eventing import Poller
+
+
+class DuplicateClient:
+    def __init__(self) -> None:
+        self.responses: list[dict[str, Any]] = [
+            {
+                "results": [
+                    {"id": "10", "version": {"when": "2024-01-02T00:00:00Z"}},
+                    {"id": "10", "version": {"when": "2024-01-02T00:00:00Z"}},
+                    {"id": "11", "version": {"when": "2024-01-03T00:00:00Z"}},
+                ],
+                "start": 0,
+                "limit": 25,
+            }
+        ]
+        self.calls = 0
+
+    def search_cql(self, *_, **kwargs) -> dict[str, Any]:  # noqa: ANN401
+        limit = kwargs.get("limit")
+        if self.calls == 0:
+            resp = dict(self.responses[0])
+            if limit is not None:
+                resp["results"] = resp["results"][:limit]
+        else:
+            resp = {"results": [], "start": 0, "limit": 0}
+        self.calls += 1
+        return resp
+
+
+def test_poller_skips_duplicate_ids(tmp_path: Path) -> None:
+    client = DuplicateClient()
+    poller = Poller(client)  # type: ignore[arg-type]
+
+    state_file = tmp_path / "cursor.json"
+    count = poller.poll_once(base_cql="type=page", state_file=state_file, limit=10)
+
+    assert count == 2  # one duplicate skipped
+    assert client.calls == 2  # second call returns empty page

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

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from confluence_orchestrator.eventing import Poller
+
+
+class PagedClient:
+    def __init__(self) -> None:
+        self.responses: list[dict[str, Any]] = [
+            {
+                "results": [
+                    {"id": "10", "version": {"when": "2024-01-02T00:00:00Z"}},
+                ],
+                "start": 0,
+                "limit": 1,
+            },
+            {
+                "results": [
+                    {"id": "11", "version": {"when": "2024-01-03T00:00:00Z"}},
+                ],
+                "start": 1,
+                "limit": 1,
+            },
+        ]
+        self.calls = 0
+
+    def search_cql(self, *_, **kwargs) -> dict[str, Any]:  # noqa: ANN401
+        limit = kwargs.get("limit")
+        if self.calls < len(self.responses):
+            resp = dict(self.responses[self.calls])
+            if limit is not None:
+                resp["results"] = resp["results"][:limit]
+        else:
+            resp = {"results": [], "start": 0, "limit": 0}
+        self.calls += 1
+        return resp
+
+
+def test_poller_respects_max_results(tmp_path: Path) -> None:
+    client = PagedClient()
+    poller = Poller(client)  # type: ignore[arg-type]
+    state_file = tmp_path / "cursor.json"
+
+    count = poller.poll_once(base_cql="type=page", state_file=state_file, limit=1, max_results=1)
+
+    assert count == 1
+    assert client.calls == 1

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

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from pathlib import Path
+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 = True  # type: ignore[attr-defined]
+    client._with_retry = lambda operation, _: operation()  # type: ignore[assignment]
+    return client, inner
+
+
+# ---------------------------------------------------------------------------
+# Client method coverage
+# ---------------------------------------------------------------------------
+
+
+def test_client_export_page_cloud_mode_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.export_page.return_value = b"%PDF-1.4 fake pdf content"
+
+    result = client.export_page("12345")
+
+    assert result == b"%PDF-1.4 fake pdf content"
+    # SDK auto-detects Cloud/Server mode, so api_version is not passed
+    inner.export_page.assert_called_once_with("12345")
+
+
+def test_client_export_page_server_mode_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    client._is_cloud = False  # type: ignore[attr-defined]
+    inner.export_page.return_value = b"%PDF-1.4 fake pdf content"
+
+    result = client.export_page("12345")
+
+    assert result == b"%PDF-1.4 fake pdf content"
+    # SDK auto-detects Cloud/Server mode, so api_version is not passed
+    inner.export_page.assert_called_once_with("12345")
+
+
+def test_client_export_page_with_explicit_api_version() -> None:
+    client, inner = _build_fake_client()
+    inner.export_page.return_value = b"%PDF-1.4 fake pdf content"
+
+    result = client.export_page("12345", api_version="server")
+
+    assert result == b"%PDF-1.4 fake pdf content"
+    # SDK auto-detects Cloud/Server mode, so api_version parameter is accepted but not passed to SDK
+    inner.export_page.assert_called_once_with("12345")
+
+
+def test_client_export_page_handles_file_path() -> None:
+    client, inner = _build_fake_client()
+    # Mock file path return
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(delete=False) as tmp:
+        tmp.write(b"%PDF-1.4 fake pdf content")
+        tmp_path = tmp.name
+
+    inner.export_page.return_value = tmp_path
+
+    result = client.export_page("12345")
+
+    assert result == b"%PDF-1.4 fake pdf content"
+    # Cleanup
+    Path(tmp_path).unlink()
+
+
+def test_client_get_space_export_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.get_space_export.return_value = "https://example.com/export/space.pdf"
+
+    result = client.get_space_export("ABC", "pdf")
+
+    assert result == "https://example.com/export/space.pdf"
+    inner.get_space_export.assert_called_once_with("ABC", "pdf")
+
+
+def test_client_get_space_export_with_different_types() -> None:
+    client, inner = _build_fake_client()
+    inner.get_space_export.return_value = "https://example.com/export/space.html"
+
+    result = client.get_space_export("ABC", "html")
+
+    assert result == "https://example.com/export/space.html"
+    inner.get_space_export.assert_called_once_with("ABC", "html")
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummyExportClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+
+    def export_page(self, page_id: str, api_version: str | None = None) -> bytes:
+        self.calls.append(("export_page", (page_id,), {"api_version": api_version}))
+        return b"%PDF-1.4 fake pdf content"
+
+    def get_space_export(self, space_key: str, export_type: str) -> str:
+        self.calls.append(("get_space_export", (space_key, export_type), {}))
+        return f"https://example.com/export/{space_key}.{export_type}"
+
+
+def test_cli_export_page_success(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    output_file = tmp_path / "test.pdf"
+    result = runner.invoke(app, ["export", "page", "--page-id", "12345", "--output", str(output_file)])
+
+    assert result.exit_code == 0
+    assert output_file.exists()
+    assert output_file.read_bytes() == b"%PDF-1.4 fake pdf content"
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "export_page"
+
+
+def test_cli_export_page_requires_page_id(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["export", "page"])
+
+    assert result.exit_code != 0
+    assert "--page-id required" in result.stdout or "--page-id required" in result.stderr
+
+
+def test_cli_export_page_with_api_version(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    output_file = tmp_path / "test.pdf"
+    result = runner.invoke(app, ["export", "page", "--page-id", "12345", "--api-version", "server", "--output", str(output_file)])
+
+    assert result.exit_code == 0
+    assert client.calls[0][2]["api_version"] == "server"
+
+
+def test_cli_export_space_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["export", "space", "--space-key", "ABC", "--export-type", "pdf"])
+
+    assert result.exit_code == 0
+    assert "ABC" in result.stdout or "download_url" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_space_export"
+
+
+def test_cli_export_space_requires_space_key(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["export", "space", "--export-type", "pdf"])
+
+    assert result.exit_code != 0
+    assert "--space-key required" in result.stdout or "--space-key required" in result.stderr
+
+
+def test_cli_export_space_requires_export_type(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["export", "space", "--space-key", "ABC"])
+
+    assert result.exit_code != 0
+    assert "--export-type required" in result.stdout or "--export-type required" in result.stderr
+
+
+def test_cli_export_space_validates_export_type(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["export", "space", "--space-key", "ABC", "--export-type", "invalid"])
+
+    assert result.exit_code != 0
+    assert "must be one of" in result.stdout or "must be one of" in result.stderr
+
+
+def test_cli_export_space_with_different_types(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    for export_type in ("pdf", "html", "xml"):
+        result = runner.invoke(app, ["export", "space", "--space-key", "ABC", "--export-type", export_type])
+        assert result.exit_code == 0
+
+
+def test_cli_export_invalid_action(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyExportClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["export", "invalid"])
+
+    assert result.exit_code != 0
+    assert "Unknown action" in result.stdout or "Unknown action" in result.stderr
+