@ngocsangairvds/vsaf 4.0.6 → 4.0.8

package/skills/vds-skill/vds-scripts/confluence_orchestrator/tests/test_advanced_content.py

@@ -0,0 +1,252 @@
+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()
+    client._safe_signature_params = (  # type: ignore[assignment]
+        lambda method: (
+            ["space_key", "page_id", "target_id", "target_title", "position"] if method is inner.move_page else []
+        )
+    )
+    inner.get_page_space.return_value = "TTTC"
+    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("TTTC", "123", target_title="Target Page", position="append")
+
+
+def test_client_move_page_with_position() -> None:
+    client, inner = _build_fake_client()
+    client._safe_signature_params = (  # type: ignore[assignment]
+        lambda method: (
+            ["space_key", "page_id", "target_id", "target_title", "position"] if method is inner.move_page else []
+        )
+    )
+    inner.get_page_space.return_value = "TTTC"
+    inner.move_page.return_value = {"id": "123"}
+
+    client.move_page("123", "Target Page", position="before")
+
+    inner.move_page.assert_called_once_with("TTTC", "123", target_title="Target Page", position="above")
+
+
+def test_client_move_page_modern_sdk_contract() -> None:
+    client, inner = _build_fake_client()
+    client._safe_signature_params = (  # type: ignore[assignment]
+        lambda method: ["page_id", "target_title", "position"] if method is inner.move_page else []
+    )
+    inner.move_page.return_value = {"id": "123", "title": "Moved Page"}
+
+    result = client.move_page("123", "Target Page", position="after")
+
+    assert result["id"] == "123"
+    inner.move_page.assert_called_once_with("123", "Target Page", position="after")
+
+
+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/skills/vds-skill/vds-scripts/confluence_orchestrator/tests/test_advanced_search.py

@@ -0,0 +1,193 @@
+"""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 VDSClientError
+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.get.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.get.assert_called_once()
+        call_args = mock_sdk_client.get.call_args
+        assert call_args[0][0] == "rest/api/search"
+        params = call_args[1]["params"]
+        assert params["limit"] == 50
+        assert params["start"] == 10
+        assert params["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.get.return_value = {"results": [], "size": 0}
+
+        server_client.cql_advanced("type = page", expand=["body.storage", "space"])
+
+        params = mock_sdk_client.get.call_args[1]["params"]
+        assert params["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.get.return_value = {"results": [], "size": 0}
+
+        server_client.cql_advanced("type = page")
+
+        params = mock_sdk_client.get.call_args[1]["params"]
+        assert params["limit"] == 25
+        assert params["start"] == 0
+        assert "excerpt" not in params
+
+
+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.get.return_value = {"results": [], "size": 0}
+
+        server_client.search_by_space_and_type(space_key="TEST")
+
+        params = mock_sdk_client.get.call_args[1]["params"]
+        assert 'space = "TEST"' in params["cql"]
+
+    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.get.return_value = {"results": [], "size": 0}
+
+        server_client.search_by_space_and_type(content_type="page")
+
+        params = mock_sdk_client.get.call_args[1]["params"]
+        assert 'type = "page"' in params["cql"]
+
+    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.get.return_value = {"results": [], "size": 0}
+
+        server_client.search_by_space_and_type(space_key="TEST", content_type="page")
+
+        params = mock_sdk_client.get.call_args[1]["params"]
+        assert 'space = "TEST"' in params["cql"]
+        assert 'type = "page"' in params["cql"]
+        assert " AND " in params["cql"]
+
+    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(VDSClientError, match="At least one of space_key, content_type, or last_modified_after"):
+            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/skills/vds-skill/vds-scripts/confluence_orchestrator/tests/test_async_client.py

@@ -0,0 +1,104 @@
+"""Tests for async_client.py — platform_core-composed Confluence HTTP client."""
+
+from __future__ import annotations
+
+import pytest
+from confluence_orchestrator.async_client import SERVICE_NAME, build_confluence_client
+from vds_platform_core.errors import AuthError, ClientPermissionError, ConflictError, NotFoundError, RateLimitError
+from vds_platform_core.http.errors import map_http_error
+from vds_platform_core.protocols import HTTPClient
+
+
+def _make_settings(**overrides):
+    """Return a minimal ConfluenceSettings suitable for unit tests."""
+    from confluence_orchestrator.config import ConfluenceSettings
+
+    return ConfluenceSettings(
+        **{
+            "VDS_USERNAME": "test",
+            "VDS_PASSWORD": "test_pass",
+            "INTERNAL_CONFLUENCE_TOKEN": "internal_tok",
+            "EXTERNAL_CONFLUENCE_TOKEN": "external_tok",
+            **overrides,
+        }
+    )
+
+
+# ---------------------------------------------------------------------------
+# Error-mapping registration (side effect of module import)
+# ---------------------------------------------------------------------------
+
+
+def test_confluence_error_map_401_returns_auth_error() -> None:
+    err = map_http_error(401, "Unauthorized", service=SERVICE_NAME)
+    assert isinstance(err, AuthError)
+
+
+def test_confluence_error_map_403_returns_permission_error() -> None:
+    err = map_http_error(403, "Forbidden", service=SERVICE_NAME)
+    assert isinstance(err, ClientPermissionError)
+
+
+def test_confluence_error_map_404_returns_not_found() -> None:
+    err = map_http_error(404, "Not found", service=SERVICE_NAME)
+    assert isinstance(err, NotFoundError)
+
+
+def test_confluence_error_map_409_returns_conflict_error() -> None:
+    err = map_http_error(409, "Conflict", service=SERVICE_NAME)
+    assert isinstance(err, ConflictError)
+
+
+def test_confluence_error_map_429_returns_rate_limit_error() -> None:
+    err = map_http_error(429, "Rate limited", service=SERVICE_NAME)
+    assert isinstance(err, RateLimitError)
+
+
+# ---------------------------------------------------------------------------
+# build_confluence_client factory
+# ---------------------------------------------------------------------------
+
+
+def test_build_confluence_client_returns_http_client_protocol(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("INTERNAL_CONFLUENCE_TOKEN", "tok")
+    settings = _make_settings()
+    client = build_confluence_client(settings, server="internal")
+    assert isinstance(client, HTTPClient)
+
+
+def test_build_confluence_client_external_server(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("EXTERNAL_CONFLUENCE_TOKEN", "ext_tok")
+    settings = _make_settings()
+    client = build_confluence_client(settings, server="external")
+    assert isinstance(client, HTTPClient)
+
+
+def test_build_confluence_client_defaults_to_settings_default_server(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("INTERNAL_CONFLUENCE_TOKEN", "tok")
+    settings = _make_settings()
+    # default_server is "internal"
+    assert settings.default_server == "internal"
+    client = build_confluence_client(settings)
+    assert isinstance(client, HTTPClient)
+
+
+def test_build_confluence_client_unknown_server_raises(monkeypatch: pytest.MonkeyPatch) -> None:
+    settings = _make_settings()
+    with pytest.raises(ValueError, match="Unknown Confluence server alias 'bogus'"):
+        build_confluence_client(settings, server="bogus")
+
+
+@pytest.mark.parametrize("alias", ["int", "main"])
+def test_build_confluence_client_accepts_internal_aliases(alias: str, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("INTERNAL_CONFLUENCE_TOKEN", "tok")
+    settings = _make_settings()
+    client = build_confluence_client(settings, server=alias)
+    assert isinstance(client, HTTPClient)
+
+
+@pytest.mark.parametrize("alias", ["ext", "outsource"])
+def test_build_confluence_client_accepts_external_aliases(alias: str, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("EXTERNAL_CONFLUENCE_TOKEN", "ext_tok")
+    settings = _make_settings()
+    client = build_confluence_client(settings, server=alias)
+    assert isinstance(client, HTTPClient)