@ngocsangairvds/vsaf 3.1.27 → 3.2.1

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

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import json
+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(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)
+
+
+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._with_retry = lambda operation, _: operation()  # type: ignore[assignment]
+    return client, inner
+
+
+# ---------------------------------------------------------------------------
+# Client method coverage
+# ---------------------------------------------------------------------------
+
+
+def test_client_archive_space_calls_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.archive_space.return_value = {"status": "archived"}
+
+    result = client.archive_space("ABC")
+
+    assert result == {"status": "archived"}
+    inner.archive_space.assert_called_once_with("ABC")
+
+
+def test_client_get_trashed_contents_passes_arguments() -> None:
+    client, inner = _build_fake_client()
+    inner.get_trashed_contents_by_space.return_value = {"results": []}
+
+    result = client.get_trashed_contents_by_space("ABC", cursor="cur", expand="children", limit=25)
+
+    assert result == {"results": []}
+    inner.get_trashed_contents_by_space.assert_called_once_with("ABC", cursor="cur", expand="children", limit=25)
+
+
+def test_client_remove_trashed_contents_calls_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.remove_trashed_contents_by_space.return_value = {"status": "removed"}
+
+    result = client.remove_trashed_contents_by_space("ABC")
+
+    assert result == {"status": "removed"}
+    inner.remove_trashed_contents_by_space.assert_called_once_with("ABC")
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummySpaceManagementClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+
+    def archive_space(self, space_key: str) -> dict[str, Any]:
+        self.calls.append(("archive", (space_key,), {}))
+        return {"status": "archived"}
+
+    def get_trashed_contents_by_space(
+        self,
+        space_key: str,
+        *,
+        cursor: str | None = None,
+        expand: str | None = None,
+        limit: int = 100,
+    ) -> dict[str, Any]:
+        self.calls.append(("trash_list", (space_key,), {"cursor": cursor, "expand": expand, "limit": limit}))
+        return {"results": [{"title": "Page"}], "size": 1}
+
+    def remove_trashed_contents_by_space(self, space_key: str) -> dict[str, Any]:
+        self.calls.append(("trash_remove", (space_key,), {}))
+        return {"status": "removed"}
+
+
+@pytest.fixture
+def dummy_client(monkeypatch: pytest.MonkeyPatch) -> DummySpaceManagementClient:
+    client = DummySpaceManagementClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args, **kwargs: client)
+    return client
+
+
+def test_cli_space_management_archive_requires_yes(dummy_client: DummySpaceManagementClient, tmp_path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-management",
+            "archive",
+            "--space-key",
+            "ABC",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "--yes required" in result.stderr or "--yes required" in result.output
+    assert not dummy_client.calls
+
+
+def test_cli_space_management_archive_success(dummy_client: DummySpaceManagementClient, tmp_path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-management",
+            "archive",
+            "--space-key",
+            "ABC",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["action"] == "archive"
+    assert dummy_client.calls[0][0] == "archive"
+
+
+def test_cli_space_management_trash_list_success(dummy_client: DummySpaceManagementClient, tmp_path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-management",
+            "trash-list",
+            "--space-key",
+            "ABC",
+            "--cursor",
+            "cur",
+            "--limit",
+            "25",
+            "--expand",
+            "children",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["action"] == "trash-list"
+    assert dummy_client.calls[0][2]["limit"] == 25
+    assert dummy_client.calls[0][2]["cursor"] == "cur"
+
+
+def test_cli_space_management_trash_remove_success(dummy_client: DummySpaceManagementClient, tmp_path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-management",
+            "trash-remove",
+            "--space-key",
+            "ABC",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["action"] == "trash-remove"
+    assert dummy_client.calls[0][0] == "trash_remove"
+
+
+def test_cli_space_management_limit_validation(dummy_client: DummySpaceManagementClient, tmp_path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-management",
+            "trash-list",
+            "--space-key",
+            "ABC",
+            "--limit",
+            "500",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "must be between 1 and 100" in result.stderr or "must be between 1 and 100" in result.output
+    assert not dummy_client.calls
+
+
+def test_cli_space_management_unknown_action(dummy_client: DummySpaceManagementClient, tmp_path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-management",
+            "unknown",
+            "--space-key",
+            "ABC",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "Unknown action" in result.stderr or "Unknown action" in result.output
+    assert not dummy_client.calls
+

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

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import json
+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._with_retry = lambda operation, _: operation()  # type: ignore[assignment]
+    return client, inner
+
+
+# ---------------------------------------------------------------------------
+# Client method coverage
+# ---------------------------------------------------------------------------
+
+
+def test_client_get_space_permissions_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.get_space_permissions.return_value = [{"id": 1}]
+
+    result = client.get_space_permissions("ABC")
+
+    assert result == [{"id": 1}]
+    inner.get_space_permissions.assert_called_once_with("ABC")
+
+
+def test_client_set_permissions_to_user_for_space_passes_operations() -> None:
+    client, inner = _build_fake_client()
+    client.set_permissions_to_user_for_space("ABC", "user-key", operations=["read", "write"])
+
+    inner.set_permissions_to_user_for_space.assert_called_once_with("ABC", "user-key", operations=["read", "write"])
+
+
+def test_client_remove_permissions_from_group_for_space() -> None:
+    client, inner = _build_fake_client()
+    client.remove_permissions_from_group_for_space("ABC", "admins")
+
+    inner.remove_permissions_from_group_for_space.assert_called_once_with("ABC", "admins")
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummySpacePermissionsClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+
+    def get_space_permissions(self, space_key: str) -> list[dict[str, Any]]:
+        self.calls.append(("get", (space_key,), {}))
+        return [{"type": "user"}]
+
+    def set_permissions_to_user_for_space(
+        self, space_key: str, user_key: str, *, operations: list[str] | None = None
+    ) -> dict[str, Any]:
+        self.calls.append(("set_user", (space_key, user_key), {"operations": operations}))
+        return {"status": "ok"}
+
+    def set_permissions_to_group_for_space(
+        self, space_key: str, group_name: str, *, operations: list[str] | None = None
+    ) -> dict[str, Any]:
+        self.calls.append(("set_group", (space_key, group_name), {"operations": operations}))
+        return {"status": "ok"}
+
+    def set_permissions_to_anonymous_for_space(self, space_key: str, *, operations: list[str] | None = None) -> dict[str, Any]:
+        self.calls.append(("set_anonymous", (space_key,), {"operations": operations}))
+        return {"status": "ok"}
+
+    def set_permissions_to_multiple_items_for_space(
+        self, space_key: str, items: list[dict[str, Any]]
+    ) -> dict[str, Any]:
+        self.calls.append(("bulk_set", (space_key,), {"items": items}))
+        return {"status": "ok"}
+
+    def remove_permissions_from_user_for_space(self, space_key: str, user_key: str) -> dict[str, Any]:
+        self.calls.append(("remove_user", (space_key, user_key), {}))
+        return {"status": "ok"}
+
+    def remove_permissions_from_group_for_space(self, space_key: str, group_name: str) -> dict[str, Any]:
+        self.calls.append(("remove_group", (space_key, group_name), {}))
+        return {"status": "ok"}
+
+    def remove_permissions_from_anonymous_for_space(self, space_key: str) -> dict[str, Any]:
+        self.calls.append(("remove_anonymous", (space_key,), {}))
+        return {"status": "ok"}
+
+
+@pytest.fixture
+def dummy_client(monkeypatch: pytest.MonkeyPatch) -> DummySpacePermissionsClient:
+    client = DummySpacePermissionsClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args, **kwargs: client)
+    return client
+
+
+def test_cli_space_permissions_get_success(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        ["--report-dir", str(tmp_path), "space-permissions", "get", "--space-key", "ABC", "--json"],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["space"] == "ABC"
+    assert payload["permissions"] == [{"type": "user"}]
+    assert dummy_client.calls[0][0] == "get"
+
+
+def test_cli_space_permissions_set_requires_yes(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "set",
+            "--space-key",
+            "ABC",
+            "--user",
+            "user-1",
+            "--operation",
+            "read",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "--yes required" in result.stderr or "--yes required" in result.output
+    assert not dummy_client.calls
+
+
+def test_cli_space_permissions_set_user_success(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "set",
+            "--space-key",
+            "ABC",
+            "--user",
+            "user-1",
+            "--operation",
+            "read",
+            "--operation",
+            "write",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["operations"] == ["read", "write"]
+    assert dummy_client.calls[0][0] == "set_user"
+    assert dummy_client.calls[0][2]["operations"] == ["read", "write"]
+
+
+def test_cli_space_permissions_set_anonymous_success(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "set",
+            "--space-key",
+            "ABC",
+            "--anonymous",
+            "--operation",
+            "read",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["target"]["type"] == "anonymous"
+    assert dummy_client.calls[0][0] == "set_anonymous"
+
+
+def test_cli_space_permissions_set_bulk_from_file(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    data = [{"target": {"type": "group", "value": "admins"}, "operations": ["read"]}]
+    permissions_file = tmp_path / "permissions.json"
+    permissions_file.write_text(json.dumps(data))
+
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "set",
+            "--space-key",
+            "ABC",
+            "--permissions-file",
+            str(permissions_file),
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["bulk"] is True
+    assert payload["items_processed"] == 1
+    assert dummy_client.calls[0][0] == "bulk_set"
+
+
+def test_cli_space_permissions_remove_group_success(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "remove",
+            "--space-key",
+            "ABC",
+            "--group",
+            "admins",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["target"]["type"] == "group"
+    assert dummy_client.calls[0][0] == "remove_group"
+
+
+def test_cli_space_permissions_remove_anonymous_success(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "remove",
+            "--space-key",
+            "ABC",
+            "--anonymous",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["target"]["type"] == "anonymous"
+    assert dummy_client.calls[0][0] == "remove_anonymous"
+
+
+def test_cli_space_permissions_set_multiple_targets_error(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "set",
+            "--space-key",
+            "ABC",
+            "--user",
+            "user-1",
+            "--group",
+            "admins",
+            "--operation",
+            "read",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "exactly one" in result.stderr or "exactly one" in result.output
+    assert not dummy_client.calls
+
+
+def test_cli_space_permissions_set_requires_operations_when_user(dummy_client: DummySpacePermissionsClient, tmp_path: Path) -> None:
+    result = runner.invoke(
+        app,
+        [
+            "--report-dir",
+            str(tmp_path),
+            "space-permissions",
+            "set",
+            "--space-key",
+            "ABC",
+            "--user",
+            "user-1",
+            "--yes",
+            "--json",
+        ],
+    )
+
+    assert result.exit_code != 0
+    assert "At least one --operation required" in result.stderr or "At least one --operation required" in result.output
+    assert not dummy_client.calls
+