@ngocsangairvds/vsaf 3.1.27 → 3.2.1

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

@@ -0,0 +1,224 @@
+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_get_page_ancestors_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.get_page_ancestors.return_value = [{"id": "1", "title": "Parent 1"}, {"id": "2", "title": "Parent 2"}]
+
+    result = client.get_page_ancestors("123")
+
+    assert len(result) == 2
+    assert result[0]["title"] == "Parent 1"
+    inner.get_page_ancestors.assert_called_once_with("123")
+
+
+def test_client_move_page_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.move_page.return_value = {"id": "123", "title": "Moved Page"}
+
+    result = client.move_page("123", "Target Page", position="append")
+
+    assert result["id"] == "123"
+    inner.move_page.assert_called_once_with("123", "Target Page", position="append")
+
+
+def test_client_move_page_with_position() -> None:
+    client, inner = _build_fake_client()
+    inner.move_page.return_value = {"id": "123"}
+
+    client.move_page("123", "Target Page", position="before")
+
+    inner.move_page.assert_called_once_with("123", "Target Page", position="before")
+
+
+def test_client_get_tables_from_page_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.get_tables_from_page.return_value = [{"rows": 2, "cols": 3}, {"rows": 1, "cols": 2}]
+
+    result = client.get_tables_from_page("123")
+
+    assert len(result) == 2
+    inner.get_tables_from_page.assert_called_once_with("123")
+
+
+def test_client_scrap_regex_from_page_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.scrap_regex_from_page.return_value = [{"match": "test1"}, {"match": "test2"}]
+
+    result = client.scrap_regex_from_page("123", r"\d+")
+
+    assert len(result) == 2
+    inner.scrap_regex_from_page.assert_called_once_with("123", r"\d+")
+
+
+def test_client_get_all_restrictions_for_content_invokes_sdk() -> None:
+    client, inner = _build_fake_client()
+    inner.get_all_restrictions_for_content.return_value = {"read": ["user1"], "write": ["user2"]}
+
+    result = client.get_all_restrictions_for_content("123")
+
+    assert "read" in result
+    inner.get_all_restrictions_for_content.assert_called_once_with("123")
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummyAdvancedContentClient:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, tuple[Any, ...], dict[str, Any]]] = []
+
+    def get_page_ancestors(self, page_id: str) -> list[dict[str, Any]]:
+        self.calls.append(("get_page_ancestors", (page_id,), {}))
+        return [{"id": "1", "title": "Parent"}]
+
+    def move_page(self, page_id: str, target_title: str, position: str = "append") -> dict[str, Any]:
+        self.calls.append(("move_page", (page_id, target_title), {"position": position}))
+        return {"id": page_id, "moved": True}
+
+    def get_tables_from_page(self, page_id: str) -> list[dict[str, Any]]:
+        self.calls.append(("get_tables_from_page", (page_id,), {}))
+        return [{"rows": 2, "cols": 3}]
+
+    def scrap_regex_from_page(self, page_id: str, regex: str) -> list[dict[str, Any]]:
+        self.calls.append(("scrap_regex_from_page", (page_id, regex), {}))
+        return [{"match": "test"}]
+
+    def get_all_restrictions_for_content(self, content_id: str) -> dict[str, Any]:
+        self.calls.append(("get_all_restrictions_for_content", (content_id,), {}))
+        return {"read": ["user1"]}
+
+
+def test_cli_content_ancestors_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "ancestors", "123"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_page_ancestors"
+
+
+def test_cli_content_move_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "move", "123", "--target-title", "Target Page", "--position", "append", "--yes"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "move_page"
+    assert client.calls[0][2]["position"] == "append"
+
+
+def test_cli_content_move_requires_yes(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "move", "123", "--target-title", "Target Page"])
+
+    assert result.exit_code != 0
+    assert "--yes required" in result.stdout or "--yes required" in result.stderr
+
+
+def test_cli_content_move_validates_position(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "move", "123", "--target-title", "Target", "--position", "invalid", "--yes"])
+
+    assert result.exit_code != 0
+    assert "must be one of" in result.stdout or "must be one of" in result.stderr
+
+
+def test_cli_content_tables_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "tables", "123"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_tables_from_page"
+
+
+def test_cli_content_regex_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "regex", "123", "--pattern", r"\d+"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "scrap_regex_from_page"
+
+
+def test_cli_content_regex_requires_pattern(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "regex", "123"])
+
+    assert result.exit_code != 0
+    # Typer will show error about missing required option
+
+
+def test_cli_content_restrictions_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyAdvancedContentClient()
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["content", "restrictions", "123"])
+
+    assert result.exit_code == 0
+    assert "123" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_all_restrictions_for_content"
+

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

@@ -0,0 +1,188 @@
+"""Tests for Confluence advanced CQL search."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+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
+def mock_settings() -> ConfluenceSettings:
+    """Mock ConfluenceSettings."""
+    return ConfluenceSettings.model_validate(
+        {
+            "VDS_USERNAME": "test_user",
+            "VDS_PASSWORD": "test_pass",
+            "INTERNAL_CONFLUENCE_TOKEN": "token-int",
+            "EXTERNAL_CONFLUENCE_TOKEN": "token-ext",
+            "INTERNAL_CONFLUENCE_URL": "http://internal.confluence.com",
+            "EXTERNAL_CONFLUENCE_URL": "http://external.confluence.com",
+        }
+    )
+
+
+@pytest.fixture
+def mock_sdk_client() -> MagicMock:
+    """Mock the underlying AtlassianConfluenceServer client."""
+    with patch("confluence_orchestrator.http.AtlassianConfluenceServer") as mock:
+        yield mock.return_value
+
+
+@pytest.fixture
+def server_client(mock_settings: ConfluenceSettings, mock_sdk_client: MagicMock) -> ConfluenceClient:
+    """Return a ConfluenceClient configured for server mode."""
+    client = ConfluenceClient(mock_settings, server="internal")
+    client._client = mock_sdk_client
+    client._is_cloud = False
+    client._with_retry = lambda operation, _: operation()
+    return client
+
+
+class TestCqlAdvanced:
+    """Tests for cql_advanced method."""
+
+    def test_cql_advanced_success(self, server_client: ConfluenceClient, mock_sdk_client: MagicMock) -> None:
+        """Test successful advanced CQL search."""
+        mock_sdk_client.cql.return_value = {"results": [{"id": "123", "title": "Test Page"}], "size": 1}
+
+        result = server_client.cql_advanced("type = page", limit=50, start=10, excerpt="highlighted")
+
+        assert result["size"] == 1
+        mock_sdk_client.cql.assert_called_once()
+        call_kwargs = mock_sdk_client.cql.call_args[1]
+        assert call_kwargs["limit"] == 50
+        assert call_kwargs["start"] == 10
+        assert call_kwargs["excerpt"] == "highlighted"
+
+    def test_cql_advanced_with_expand(self, server_client: ConfluenceClient, mock_sdk_client: MagicMock) -> None:
+        """Test advanced CQL search with expand option."""
+        mock_sdk_client.cql.return_value = {"results": [], "size": 0}
+
+        server_client.cql_advanced("type = page", expand=["body.storage", "space"])
+
+        call_kwargs = mock_sdk_client.cql.call_args[1]
+        assert call_kwargs["expand"] == "body.storage,space"
+
+    def test_cql_advanced_defaults(self, server_client: ConfluenceClient, mock_sdk_client: MagicMock) -> None:
+        """Test advanced CQL search with default parameters."""
+        mock_sdk_client.cql.return_value = {"results": [], "size": 0}
+
+        server_client.cql_advanced("type = page")
+
+        call_kwargs = mock_sdk_client.cql.call_args[1]
+        assert call_kwargs["limit"] == 25
+        assert call_kwargs["start"] == 0
+        assert "excerpt" not in call_kwargs or call_kwargs.get("excerpt") is None
+
+
+class TestSearchBySpaceAndType:
+    """Tests for search_by_space_and_type method."""
+
+    def test_search_by_space_and_type_space_only(self, server_client: ConfluenceClient, mock_sdk_client: MagicMock) -> None:
+        """Test search by space only."""
+        mock_sdk_client.cql.return_value = {"results": [], "size": 0}
+
+        server_client.search_by_space_and_type(space_key="TEST")
+
+        call_args = mock_sdk_client.cql.call_args[0]
+        assert 'space = "TEST"' in call_args[0]
+
+    def test_search_by_space_and_type_type_only(self, server_client: ConfluenceClient, mock_sdk_client: MagicMock) -> None:
+        """Test search by content type only."""
+        mock_sdk_client.cql.return_value = {"results": [], "size": 0}
+
+        server_client.search_by_space_and_type(content_type="page")
+
+        call_args = mock_sdk_client.cql.call_args[0]
+        assert 'type = "page"' in call_args[0]
+
+    def test_search_by_space_and_type_both(self, server_client: ConfluenceClient, mock_sdk_client: MagicMock) -> None:
+        """Test search by both space and type."""
+        mock_sdk_client.cql.return_value = {"results": [], "size": 0}
+
+        server_client.search_by_space_and_type(space_key="TEST", content_type="page")
+
+        call_args = mock_sdk_client.cql.call_args[0]
+        assert 'space = "TEST"' in call_args[0]
+        assert 'type = "page"' in call_args[0]
+        assert " AND " in call_args[0]
+
+    def test_search_by_space_and_type_requires_at_least_one(self, server_client: ConfluenceClient) -> None:
+        """Test that search_by_space_and_type requires at least one parameter."""
+        with pytest.raises(ConfluenceClientError, match="At least one of space_key or content_type"):
+            server_client.search_by_space_and_type()
+
+
+# ---------------------------------------------------------------------------
+# CLI command tests
+# ---------------------------------------------------------------------------
+
+
+class DummySearchClient:
+    def __init__(self, cloud: bool = False) -> None:
+        self.calls: list = []
+        self._is_cloud = cloud  # type: ignore[attr-defined]
+
+    def search_cql(self, cql: str, **kwargs: any) -> dict:
+        self.calls.append(("search_cql", cql, kwargs))
+        return {"results": [], "size": 0}
+
+    def cql_advanced(self, cql: str, **kwargs: any) -> dict:
+        self.calls.append(("cql_advanced", cql, kwargs))
+        return {"results": [], "size": 0}
+
+    def search_by_space_and_type(self, **kwargs: any) -> dict:
+        self.calls.append(("search_by_space_and_type", kwargs))
+        return {"results": [], "size": 0}
+
+
+def test_cli_search_advanced_flag(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test search command with --advanced flag."""
+    client = DummySearchClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_content_client", lambda *args: client)
+
+    result = runner.invoke(app, ["search", "--cql", "type = page", "--advanced", "--excerpt", "highlighted"])
+
+    assert result.exit_code == 0
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "cql_advanced"
+    assert client.calls[0][2].get("excerpt") == "highlighted"
+
+
+def test_cli_search_by_space_type_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test search-by-space-type command success."""
+    client = DummySearchClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_content_client", lambda *args: client)
+
+    result = runner.invoke(app, ["search-by-space-type", "--space", "TEST", "--type", "page"])
+
+    assert result.exit_code == 0
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "search_by_space_and_type"
+
+
+def test_cli_search_by_space_type_requires_parameter(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test search-by-space-type command requires at least one parameter."""
+    client = DummySearchClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_content_client", lambda *args: client)
+
+    result = runner.invoke(app, ["search-by-space-type"])
+
+    assert result.exit_code != 0
+    assert (
+        "--space" in result.stdout
+        or "--type" in result.stdout
+        or "At least one" in result.stdout
+        or "--space" in result.stderr
+        or "--type" in result.stderr
+        or "At least one" in result.stderr
+    )
+

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

@@ -0,0 +1,247 @@
+"""Tests for Confluence cache management (Server-only)."""
+
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+from confluence_orchestrator.cli import app
+from confluence_orchestrator.errors import ConfluenceClientError
+from confluence_orchestrator.http import ConfluenceClient
+from typer.testing import CliRunner
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_settings():
+    """Mock Confluence settings."""
+    settings = MagicMock()
+    settings.url_for.return_value = "http://confluence.digital.vn"
+    settings.token_for.return_value = "test-token"
+    settings.username = None
+    settings.password = None
+    settings.max_retries = 3
+    settings.retry_backoff_factor = 0.5
+    settings.default_server = "internal"
+    settings.internal_token = "test-token"
+    settings.external_token = None
+    return settings
+
+
+@pytest.fixture
+def mock_sdk_client():
+    """Mock SDK client."""
+    client = MagicMock()
+    client.clean_all_caches.return_value = None
+    client.clean_package_cache.return_value = None
+    client.request.return_value = MagicMock(json=lambda: {"stats": "data"})
+    return client
+
+
+@pytest.fixture
+def server_client(mock_settings, mock_sdk_client):
+    """Create ConfluenceClient in Server mode."""
+    with patch("confluence_orchestrator.http.AtlassianConfluenceServer", return_value=mock_sdk_client):
+        client = ConfluenceClient(mock_settings, server="internal")
+        client._is_cloud = False
+        return client
+
+
+@pytest.fixture
+def cloud_client(mock_settings, mock_sdk_client):
+    """Create ConfluenceClient in Cloud mode."""
+    with patch("confluence_orchestrator.http.AtlassianConfluenceCloud", return_value=mock_sdk_client):
+        client = ConfluenceClient(mock_settings, server="internal")
+        client._is_cloud = True
+        return client
+
+
+class TestGetCacheStatistics:
+    """Tests for get_cache_statistics method."""
+
+    def test_get_cache_statistics_success(self, server_client, mock_sdk_client):
+        """Test successful cache statistics retrieval."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"cache_stats": {"hits": 100, "misses": 50}}
+        mock_sdk_client.request.return_value = mock_response
+
+        result = server_client.get_cache_statistics()
+
+        assert result == {"cache_stats": {"hits": 100, "misses": 50}}
+        mock_sdk_client.request.assert_called_once_with(method="GET", path="/rest/cache/1.0/stats")
+
+    def test_get_cache_statistics_cloud_mode_error(self, cloud_client):
+        """Test that get_cache_statistics raises error in Cloud mode."""
+        with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+            cloud_client.get_cache_statistics()
+
+    def test_get_cache_statistics_handles_response_dict(self, server_client, mock_sdk_client):
+        """Test handling when request returns dict directly."""
+        mock_sdk_client.request.return_value = {"cache_stats": {"hits": 100}}
+
+        result = server_client.get_cache_statistics()
+
+        assert result == {"cache_stats": {"hits": 100}}
+
+
+class TestFlushCache:
+    """Tests for flush_cache method."""
+
+    def test_flush_cache_all_success(self, server_client, mock_sdk_client):
+        """Test successful flush of all caches."""
+        server_client.flush_cache()
+
+        mock_sdk_client.clean_all_caches.assert_called_once()
+
+    def test_flush_cache_specific_success(self, server_client, mock_sdk_client):
+        """Test successful flush of specific cache."""
+        server_client.flush_cache(cache_name="com.gliffy.cache.gon")
+
+        mock_sdk_client.clean_package_cache.assert_called_once_with(cache_name="com.gliffy.cache.gon")
+
+    def test_flush_cache_cloud_mode_error(self, cloud_client):
+        """Test that flush_cache raises error in Cloud mode."""
+        with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+            cloud_client.flush_cache()
+
+    def test_flush_cache_specific_cloud_mode_error(self, cloud_client):
+        """Test that flush_cache with cache_name raises error in Cloud mode."""
+        with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+            cloud_client.flush_cache(cache_name="test-cache")
+
+
+class TestGetCacheSize:
+    """Tests for get_cache_size method."""
+
+    def test_get_cache_size_success(self, server_client, mock_sdk_client):
+        """Test successful cache size retrieval."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"total_size": "100MB", "cache_count": 10}
+        mock_sdk_client.request.return_value = mock_response
+
+        result = server_client.get_cache_size()
+
+        assert result == {"total_size": "100MB", "cache_count": 10}
+        mock_sdk_client.request.assert_called_once_with(method="GET", path="/rest/cache/1.0/size")
+
+    def test_get_cache_size_cloud_mode_error(self, cloud_client):
+        """Test that get_cache_size raises error in Cloud mode."""
+        with pytest.raises(ConfluenceClientError, match="only available in Confluence Server"):
+            cloud_client.get_cache_size()
+
+    def test_get_cache_size_handles_response_dict(self, server_client, mock_sdk_client):
+        """Test handling when request returns dict directly."""
+        mock_sdk_client.request.return_value = {"total_size": "50MB"}
+
+        result = server_client.get_cache_size()
+
+        assert result == {"total_size": "50MB"}
+
+
+# ---------------------------------------------------------------------------
+# CLI command coverage
+# ---------------------------------------------------------------------------
+
+
+class DummyCacheClient:
+    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_cache_statistics(self) -> dict[str, Any]:
+        if self._is_cloud:
+            raise ConfluenceClientError("Server-only feature")
+        self.calls.append(("get_cache_statistics", (), {}))
+        return {"cache_stats": {"hits": 100, "misses": 50}}
+
+    def flush_cache(self, cache_name: str | None = None) -> None:
+        if self._is_cloud:
+            raise ConfluenceClientError("Server-only feature")
+        self.calls.append(("flush_cache", (cache_name,), {}))
+
+    def get_cache_size(self) -> dict[str, Any]:
+        if self._is_cloud:
+            raise ConfluenceClientError("Server-only feature")
+        self.calls.append(("get_cache_size", (), {}))
+        return {"total_size": "100MB", "cache_count": 10}
+
+
+def test_cli_cache_statistics_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "statistics"])
+
+    assert result.exit_code == 0
+    assert "cache_statistics" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_cache_statistics"
+
+
+def test_cli_cache_flush_all_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "flush", "--yes"])
+
+    assert result.exit_code == 0
+    assert "success" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "flush_cache"
+    assert client.calls[0][1][0] is None  # cache_name is None
+
+
+def test_cli_cache_flush_specific_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "flush", "--cache-name", "com.gliffy.cache", "--yes"])
+
+    assert result.exit_code == 0
+    assert "success" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "flush_cache"
+    assert client.calls[0][1][0] == "com.gliffy.cache"
+
+
+def test_cli_cache_flush_requires_yes(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "flush"])
+
+    assert result.exit_code != 0
+    assert "--yes" in result.stdout or "--yes" in result.stderr or "without --yes" in result.stdout
+
+
+def test_cli_cache_size_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "size"])
+
+    assert result.exit_code == 0
+    assert "cache_size" in result.stdout
+    assert len(client.calls) == 1
+    assert client.calls[0][0] == "get_cache_size"
+
+
+def test_cli_cache_cloud_mode_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=True)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "statistics"])
+
+    assert result.exit_code != 0
+    assert "Server-only" in result.stderr or "Server-only" in result.stdout
+
+
+def test_cli_cache_invalid_action(monkeypatch: pytest.MonkeyPatch) -> None:
+    client = DummyCacheClient(cloud=False)
+    monkeypatch.setattr("confluence_orchestrator.cli._build_http_client", lambda *args: client)
+
+    result = runner.invoke(app, ["cache", "invalid"])
+
+    assert result.exit_code != 0
+    assert "Unknown action" in result.stdout or "Unknown action" in result.stderr
+