@ngocsangairvds/vsaf 4.1.8 → 4.1.9

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

@@ -1,130 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-from confluence_orchestrator.config import load_settings
-
-if TYPE_CHECKING:
-    import pytest
-
-
-def write_env(tmp_path: Path, content: str) -> Path:
-    env_path = tmp_path / ".env"
-    env_path.write_text(content)
-    return env_path
-
-
-def clear_runtime_env(monkeypatch: pytest.MonkeyPatch) -> None:
-    for key in (
-        "VDS_USERNAME",
-        "VDS_PASSWORD",
-        "INTERNAL_CONFLUENCE_TOKEN",
-        "EXTERNAL_CONFLUENCE_TOKEN",
-        "CONFLUENCE_DEFAULT_SERVER",
-        "CONFLUENCE_INTERNAL_URL",
-        "CONFLUENCE_EXTERNAL_URL",
-        "CONFLUENCE_EXTERNAL_ALTERNATE_URL",
-        "CONFLUENCE_INTERNAL_ALTERNATE_URL",
-        "CONFLUENCE_SECONDARY_EXTERNAL_URL",
-        "CONFLUENCE_INTERNAL_FALLBACK_URL",
-    ):
-        monkeypatch.delenv(key, raising=False)
-
-
-def test_load_settings_file_overrides_env_when_env_path_provided(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    """When env_path is given, load_shared_env(override=True) makes file values win over env."""
-    clear_runtime_env(monkeypatch)
-    env_path = write_env(
-        tmp_path,
-        """
-VDS_USERNAME=file_user
-VDS_PASSWORD=file_pass
-INTERNAL_CONFLUENCE_TOKEN=file_internal
-EXTERNAL_CONFLUENCE_TOKEN=file_external
-CONFLUENCE_DEFAULT_SERVER=external
-""".strip(),
-    )
-
-    monkeypatch.setenv("VDS_USERNAME", "env_user")
-    settings = load_settings(env_path=env_path)
-
-    assert settings.username == "file_user"
-    assert settings.password is not None and settings.password.get_secret_value() == "file_pass"
-    assert settings.internal_token is not None and settings.internal_token.get_secret_value() == "file_internal"
-    assert settings.default_server == "external"
-
-
-def test_load_settings_strict_allows_basic_auth(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    clear_runtime_env(monkeypatch)
-    env_path = write_env(
-        tmp_path,
-        """
-VDS_USERNAME=file_user
-VDS_PASSWORD=file_pass
-""".strip(),
-    )
-
-    settings = load_settings(env_path=env_path, strict=True)
-    assert settings.username == "file_user"
-    assert settings.password is not None and settings.password.get_secret_value() == "file_pass"
-
-
-def test_url_and_token_resolution(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    clear_runtime_env(monkeypatch)
-    env_path = write_env(
-        tmp_path,
-        """
-VDS_USERNAME=user
-VDS_PASSWORD=pass
-INTERNAL_CONFLUENCE_TOKEN=internal
-EXTERNAL_CONFLUENCE_TOKEN=external
-CONFLUENCE_INTERNAL_URL=http://internal.example.local
-CONFLUENCE_EXTERNAL_URL=http://external.example.local
-""".strip(),
-    )
-
-    settings = load_settings(env_path=env_path, strict=True)
-
-    assert settings.token_for("internal") == "internal"
-    assert settings.token_for("external") == "external"
-    assert str(settings.url_for("internal")).rstrip("/") == "http://internal.example.local"
-    assert str(settings.url_for("external")).rstrip("/") == "http://external.example.local"
-
-
-def test_alternate_endpoint_names_are_canonical(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    clear_runtime_env(monkeypatch)
-    env_path = write_env(
-        tmp_path,
-        """
-VDS_USERNAME=user
-VDS_PASSWORD=pass
-CONFLUENCE_EXTERNAL_ALTERNATE_URL=http://external-alt.example.local
-CONFLUENCE_INTERNAL_ALTERNATE_URL=http://internal-alt.example.local
-""".strip(),
-    )
-
-    settings = load_settings(env_path=env_path, strict=True)
-
-    assert str(settings.external_alternate_url).rstrip("/") == "http://external-alt.example.local"
-    assert str(settings.internal_alternate_url).rstrip("/") == "http://internal-alt.example.local"
-
-
-def test_legacy_fallback_env_names_map_to_alternate_endpoints(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    clear_runtime_env(monkeypatch)
-    env_path = write_env(
-        tmp_path,
-        """
-VDS_USERNAME=user
-VDS_PASSWORD=pass
-CONFLUENCE_SECONDARY_EXTERNAL_URL=http://external-legacy.example.local
-CONFLUENCE_INTERNAL_FALLBACK_URL=http://internal-legacy.example.local
-""".strip(),
-    )
-
-    settings = load_settings(env_path=env_path, strict=True)
-
-    assert str(settings.external_alternate_url).rstrip("/") == "http://external-legacy.example.local"
-    assert str(settings.internal_alternate_url).rstrip("/") == "http://internal-legacy.example.local"

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

@@ -1,192 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-import pytest
-from confluence_orchestrator.content import ContentClient
-
-
-class RecordingClient:
-    def __init__(self) -> None:
-        self.calls: dict[str, dict[str, Any]] = {}
-
-    def get_page(self, page_id: str, expand: Any = None) -> dict[str, Any]:
-        return {
-            "id": page_id,
-            "title": "Original",
-            "space": {"key": "TTTC"},
-            "version": {"number": 2},
-            "body": {"storage": {"value": "<p>old</p>", "representation": "storage"}},
-        }
-
-    def create_page(
-        self, space_key: str, title: str, body: str, parent_id: Any = None, **kwargs: Any
-    ) -> dict[str, Any]:
-        payload = {"space_key": space_key, "title": title, "body": body, "parent_id": parent_id, **kwargs}
-        self.calls["create_page"] = payload
-        return {"id": "999", **payload}
-
-    def update_page(self, page_id: str, title: str, body: Any = None, **kwargs: Any) -> dict[str, Any]:
-        payload = {"page_id": page_id, "title": title, "body": body, **kwargs}
-        self.calls["update_page"] = payload
-        return payload
-
-    def delete_page(self, page_id: str) -> None:
-        self.calls["delete_page"] = {"page_id": page_id}
-
-    # Attachment operations -------------------------------------------------
-    def add_attachment(self, page_id: str, filename: str, content: bytes, **kwargs: Any) -> dict[str, Any]:
-        self.calls["add_attachment"] = {
-            "page_id": page_id,
-            "filename": filename,
-            "size": len(content),
-            **kwargs,
-        }
-        return {"id": "att-1"}
-
-    def update_attachment_data(
-        self, page_id: str, attachment_id: str, filename: str, content: bytes, **kwargs: Any
-    ) -> dict[str, Any]:
-        self.calls["update_attachment"] = {
-            "page_id": page_id,
-            "attachment_id": attachment_id,
-            "filename": filename,
-            "size": len(content),
-            **kwargs,
-        }
-        return {"id": attachment_id}
-
-    def delete_attachment_by_id(self, page_id: str, attachment_id: str, version: Any = None) -> None:
-        self.calls["delete_attachment_by_id"] = {"page_id": page_id, "attachment_id": attachment_id, "version": version}
-
-    def delete_attachment(self, page_id: str, filename: str, version: Any = None) -> None:
-        self.calls["delete_attachment"] = {"page_id": page_id, "filename": filename, "version": version}
-
-    def get_attachments(self, page_id: str) -> dict[str, Any]:
-        return {"results": [{"id": "att-1", "title": "doc.txt"}]}
-
-    def get_attachment_content(self, attachment_id: str) -> bytes:
-        return b"file"
-
-    # Template operations ---------------------------------------------------
-    def request(self, method: str, path: str, **kwargs: Any):
-        self.calls.setdefault("requests", []).append({"method": method, "path": path, **kwargs})
-
-        class _Resp:
-            def __init__(self, payload: dict[str, Any]) -> None:
-                self._payload = payload
-
-            def json(self) -> dict[str, Any]:
-                return self._payload
-
-        if method == "GET" and path.startswith("/rest/api/template/"):
-            return _Resp(
-                {
-                    "id": path.rsplit("/", 1)[-1],
-                    "name": "Template",
-                    "templateType": "page",
-                    "description": "desc",
-                    "body": {"storage": {"value": "<p>template</p>", "representation": "storage"}},
-                }
-            )
-        if method == "GET":
-            return _Resp({"results": [{"id": "tmpl-1"}]})
-        return _Resp({"id": "tmpl-1", **kwargs.get("json", {})})
-
-
-@pytest.fixture()
-def content_client() -> tuple[ContentClient, RecordingClient]:
-    recording = RecordingClient()
-    return ContentClient(recording), recording
-
-
-def test_create_page_passes_sdk_fields(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    client.create_page(
-        space_key="TTTC", title="New Page", body="<p>hello</p>", parent_id="321", representation="storage"
-    )
-
-    payload = recording.calls["create_page"]
-    assert payload["space_key"] == "TTTC"
-    assert payload["title"] == "New Page"
-    assert payload["body"] == "<p>hello</p>"
-    assert payload["parent_id"] == "321"
-
-
-def test_update_page_uses_existing_title(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    client.update_page("123", body="<p>updated</p>", minor_edit=True, message="Updated")
-
-    payload = recording.calls["update_page"]
-    assert payload["page_id"] == "123"
-    assert payload["body"] == "<p>updated</p>"
-    assert payload["minor_edit"] is True
-    assert payload["version_comment"] == "Updated"
-
-
-def test_delete_page(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    client.delete_page("123")
-    assert recording.calls["delete_page"] == {"page_id": "123"}
-
-
-def test_upload_attachment_records_args(tmp_path: Path, content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    file_path = tmp_path / "attachment.txt"
-    file_path.write_text("data", encoding="utf-8")
-
-    client.upload_attachment("123", str(file_path), content_type="text/plain", comment="note")
-
-    payload = recording.calls["add_attachment"]
-    assert payload["page_id"] == "123"
-    assert payload["filename"].endswith("attachment.txt")
-    assert payload["comment"] == "note"
-
-
-def test_list_attachments_returns_dict(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, _ = content_client
-    payload = client.list_attachments("123")
-    assert "results" in payload
-    assert payload["results"][0]["title"] == "doc.txt"
-
-
-def test_update_attachment(content_client: tuple[ContentClient, RecordingClient], tmp_path: Path) -> None:
-    client, recording = content_client
-    file_path = tmp_path / "attachment.txt"
-    file_path.write_text("new", encoding="utf-8")
-
-    client.update_attachment("123", "att-1", str(file_path), comment="reupload")
-    payload = recording.calls["update_attachment"]
-    assert payload["attachment_id"] == "att-1"
-    assert payload["comment"] == "reupload"
-
-
-def test_delete_attachment(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    client.delete_attachment("123", "att-1", version=2)
-    assert recording.calls["delete_attachment_by_id"] == {"page_id": "123", "attachment_id": "att-1", "version": 2}
-
-
-def test_delete_attachment_by_filename(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    client.delete_attachment("123", filename="diagram.pdf")
-    assert recording.calls["delete_attachment"] == {"page_id": "123", "filename": "diagram.pdf", "version": None}
-
-
-def test_delete_attachment_requires_identifier(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, _ = content_client
-    with pytest.raises(ValueError):
-        client.delete_attachment("123")
-
-
-def test_template_operations(content_client: tuple[ContentClient, RecordingClient]) -> None:
-    client, recording = content_client
-    client.create_template(name="My Template", body="<p>body</p>", space_key="TTTC")
-    client.update_template("tmpl-1", name="Renamed")
-    client.delete_template("tmpl-1")
-
-    assert recording.calls["requests"][0]["method"] == "POST"
-    assert recording.calls["requests"][1]["method"] == "GET"
-    assert recording.calls["requests"][2]["method"] == "PUT"
-    assert recording.calls["requests"][3]["path"].endswith("tmpl-1")

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

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-import pytest
-from confluence_orchestrator.content import ContentClient
-
-
-class DummyHttp:
-    def create_page(self, *args, **kwargs):
-        return {"args": args, "kwargs": kwargs}
-
-    def update_page(self, *args, **kwargs):
-        return {"args": args, "kwargs": kwargs}
-
-
-@pytest.fixture()
-def content_client() -> ContentClient:
-    return ContentClient(DummyHttp())
-
-
-def test_notify_watchers_rejected_on_create(content_client: ContentClient) -> None:
-    with pytest.raises(ValueError):
-        content_client.create_page(space_key="TTTC", title="A", body="B", notify_watchers=True)
-
-
-def test_notify_watchers_rejected_on_update(content_client: ContentClient) -> None:
-    with pytest.raises(ValueError):
-        content_client.update_page("123", title="A", notify_watchers=True)

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

@@ -1,94 +0,0 @@
-"""Unit tests for ContentClient label methods (FR-03).
-
-Tests verify that:
-- get_page_labels() extracts 'name' strings from raw SDK result
-- set_page_label() delegates cleanly to the HTTP layer
-- Edge cases: empty result, non-dict entries in raw response
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import pytest
-from confluence_orchestrator.content import ContentClient
-
-
-class DummyHttp:
-    """Minimal ConfluenceClient stub for label-method tests."""
-
-    def __init__(self) -> None:
-        self._labels: dict[str, list[dict[str, Any]]] = {}
-        self.get_labels_calls: list[str] = []
-        self.set_label_calls: list[tuple[str, str]] = []
-
-    def get_page_labels(self, page_id: str) -> list[dict[str, Any]]:
-        self.get_labels_calls.append(page_id)
-        return self._labels.get(page_id, [])
-
-    def set_page_label(self, page_id: str, label: str) -> None:
-        self.set_label_calls.append((page_id, label))
-
-
-@pytest.fixture()
-def http() -> DummyHttp:
-    return DummyHttp()
-
-
-@pytest.fixture()
-def client(http: DummyHttp) -> ContentClient:
-    return ContentClient(http)  # type: ignore[arg-type]
-
-
-class TestGetPageLabels:
-    def test_returns_name_strings(self, client: ContentClient, http: DummyHttp) -> None:
-        http._labels["42"] = [{"name": "api"}, {"name": "backend"}]
-        assert client.get_page_labels("42") == ["api", "backend"]
-
-    def test_empty_result_returns_empty_list(self, client: ContentClient, http: DummyHttp) -> None:
-        http._labels["99"] = []
-        assert client.get_page_labels("99") == []
-
-    def test_page_with_no_registered_labels_returns_empty(self, client: ContentClient, http: DummyHttp) -> None:
-        # Key not in _labels dict — HTTP layer returns []
-        assert client.get_page_labels("7") == []
-
-    def test_delegates_to_http_with_correct_page_id(self, client: ContentClient, http: DummyHttp) -> None:
-        http._labels["7"] = [{"name": "foo"}]
-        client.get_page_labels("7")
-        assert http.get_labels_calls == ["7"]
-
-    def test_filters_non_dict_entries(self, client: ContentClient, http: DummyHttp) -> None:
-        # Guard against malformed SDK responses
-        http._labels["5"] = [{"name": "valid"}, "bad-string", None, 42]  # type: ignore[list-item]
-        result = client.get_page_labels("5")
-        assert result == ["valid"]
-
-    def test_missing_name_key_returns_empty_string(self, client: ContentClient, http: DummyHttp) -> None:
-        http._labels["3"] = [{"id": "x"}, {"name": "labeled"}]
-        result = client.get_page_labels("3")
-        assert result == ["", "labeled"]
-
-    def test_single_label(self, client: ContentClient, http: DummyHttp) -> None:
-        http._labels["1"] = [{"name": "doc"}]
-        assert client.get_page_labels("1") == ["doc"]
-
-
-class TestSetPageLabel:
-    def test_delegates_to_http(self, client: ContentClient, http: DummyHttp) -> None:
-        client.set_page_label("42", "my-label")
-        assert http.set_label_calls == [("42", "my-label")]
-
-    def test_page_id_and_label_forwarded_correctly(self, client: ContentClient, http: DummyHttp) -> None:
-        client.set_page_label("page-123", "security")
-        assert http.set_label_calls[0] == ("page-123", "security")
-
-    def test_multiple_sequential_calls_all_forwarded(self, client: ContentClient, http: DummyHttp) -> None:
-        client.set_page_label("1", "alpha")
-        client.set_page_label("1", "beta")
-        client.set_page_label("2", "gamma")
-        assert http.set_label_calls == [("1", "alpha"), ("1", "beta"), ("2", "gamma")]
-
-    def test_returns_none(self, client: ContentClient, http: DummyHttp) -> None:
-        result = client.set_page_label("1", "tag")
-        assert result is None