@ngocsangairvds/vsaf 4.1.7 → 4.1.9

package/skills/vds-skill/vds-scripts/git_orchestrator/tests/test_public_api.py

@@ -1,235 +0,0 @@
-"""
-Tests for vds_git_orchestrator public API exports (TSK-221).
-
-Validates FR-21.1.2: Export Repository, Manifest, ManifestFilters, GitOperation,
-RunSummary, orchestrate_repositories from vds_git_orchestrator.__init__
-
-These tests verify that:
-1. All public symbols can be imported from the package root
-2. The __all__ list contains all expected symbols
-3. Imported symbols are the correct types/classes
-4. Basic functionality works when using package-level imports
-"""
-
-from pathlib import Path
-
-
-class TestPublicAPIExports:
-    """Test that all public symbols are exported from package root."""
-
-    def test_import_repository_from_package_root(self) -> None:
-        """Verify Repository can be imported from vds_git_orchestrator."""
-        from vds_git_orchestrator import Repository
-
-        # Verify it's the correct class by checking it's a dataclass
-        assert hasattr(Repository, "__dataclass_fields__")
-        assert "name" in Repository.__dataclass_fields__
-        assert "path" in Repository.__dataclass_fields__
-        assert "project" in Repository.__dataclass_fields__
-        assert "branch" in Repository.__dataclass_fields__
-
-    def test_import_manifest_from_package_root(self) -> None:
-        """Verify Manifest can be imported from vds_git_orchestrator."""
-        from vds_git_orchestrator import Manifest
-
-        # Verify it's the correct class
-        assert hasattr(Manifest, "__dataclass_fields__")
-        assert "repositories" in Manifest.__dataclass_fields__
-        assert hasattr(Manifest, "merge")
-        assert hasattr(Manifest, "filter")
-
-    def test_import_manifest_filters_from_package_root(self) -> None:
-        """Verify ManifestFilters can be imported from vds_git_orchestrator."""
-        from vds_git_orchestrator import ManifestFilters
-
-        # Verify it's the correct class
-        assert hasattr(ManifestFilters, "__dataclass_fields__")
-        assert "project" in ManifestFilters.__dataclass_fields__
-        assert "name_match" in ManifestFilters.__dataclass_fields__
-        assert "include_tags" in ManifestFilters.__dataclass_fields__
-        assert "exclude_tags" in ManifestFilters.__dataclass_fields__
-
-    def test_import_git_operation_from_package_root(self) -> None:
-        """Verify GitOperation can be imported from vds_git_orchestrator."""
-        from vds_git_orchestrator import GitOperation
-
-        # Verify it's an Enum with expected values
-        assert hasattr(GitOperation, "FETCH")
-        assert hasattr(GitOperation, "PULL")
-        assert hasattr(GitOperation, "CLONE")
-        assert hasattr(GitOperation, "STATUS")
-        assert GitOperation.PULL.value == "pull"
-
-    def test_import_run_summary_from_package_root(self) -> None:
-        """Verify RunSummary can be imported from vds_git_orchestrator."""
-        from vds_git_orchestrator import RunSummary
-
-        # Verify it's the correct class
-        assert hasattr(RunSummary, "__dataclass_fields__")
-        assert "total" in RunSummary.__dataclass_fields__
-        assert "successes" in RunSummary.__dataclass_fields__
-        assert "failures" in RunSummary.__dataclass_fields__
-        assert hasattr(RunSummary, "from_results")
-        assert hasattr(RunSummary, "to_dict")
-
-    def test_import_orchestrate_repositories_from_package_root(self) -> None:
-        """Verify orchestrate_repositories can be imported from vds_git_orchestrator."""
-        # Verify it's a callable (async function)
-        import inspect
-
-        from vds_git_orchestrator import orchestrate_repositories
-
-        assert callable(orchestrate_repositories)
-        assert inspect.iscoroutinefunction(orchestrate_repositories)
-
-
-class TestAllList:
-    """Test that __all__ contains all expected public symbols."""
-
-    def test_all_list_contains_manifest_symbols(self) -> None:
-        """Verify __all__ includes Repository, Manifest, ManifestFilters."""
-        import vds_git_orchestrator
-
-        assert "Repository" in vds_git_orchestrator.__all__
-        assert "Manifest" in vds_git_orchestrator.__all__
-        assert "ManifestFilters" in vds_git_orchestrator.__all__
-
-    def test_all_list_contains_orchestrator_symbols(self) -> None:
-        """Verify __all__ includes GitOperation, RunSummary, orchestrate_repositories."""
-        import vds_git_orchestrator
-
-        assert "GitOperation" in vds_git_orchestrator.__all__
-        assert "RunSummary" in vds_git_orchestrator.__all__
-        assert "orchestrate_repositories" in vds_git_orchestrator.__all__
-
-    def test_all_list_has_exactly_six_symbols(self) -> None:
-        """Verify __all__ contains exactly the 6 expected public symbols."""
-        import vds_git_orchestrator
-
-        expected_symbols = {
-            "Repository",
-            "Manifest",
-            "ManifestFilters",
-            "GitOperation",
-            "RunSummary",
-            "orchestrate_repositories",
-            "SyncableRepo",
-        }
-        assert set(vds_git_orchestrator.__all__) == expected_symbols
-
-
-class TestImportEquivalence:
-    """Test that package-level imports are equivalent to module-level imports."""
-
-    def test_repository_import_equivalence(self) -> None:
-        """Verify package import equals module import for Repository."""
-        from vds_git_orchestrator import Repository as PkgRepository
-        from vds_git_orchestrator.manifest import Repository as ModRepository
-
-        assert PkgRepository is ModRepository
-
-    def test_manifest_import_equivalence(self) -> None:
-        """Verify package import equals module import for Manifest."""
-        from vds_git_orchestrator import Manifest as PkgManifest
-        from vds_git_orchestrator.manifest import Manifest as ModManifest
-
-        assert PkgManifest is ModManifest
-
-    def test_manifest_filters_import_equivalence(self) -> None:
-        """Verify package import equals module import for ManifestFilters."""
-        from vds_git_orchestrator import ManifestFilters as PkgFilters
-        from vds_git_orchestrator.manifest import ManifestFilters as ModFilters
-
-        assert PkgFilters is ModFilters
-
-    def test_git_operation_import_equivalence(self) -> None:
-        """Verify package import equals module import for GitOperation."""
-        from vds_git_orchestrator import GitOperation as PkgOp
-        from vds_git_orchestrator.orchestrator import GitOperation as ModOp
-
-        assert PkgOp is ModOp
-
-    def test_run_summary_import_equivalence(self) -> None:
-        """Verify package import equals module import for RunSummary."""
-        from vds_git_orchestrator import RunSummary as PkgSummary
-        from vds_git_orchestrator.orchestrator import RunSummary as ModSummary
-
-        assert PkgSummary is ModSummary
-
-    def test_orchestrate_repositories_import_equivalence(self) -> None:
-        """Verify package import equals module import for orchestrate_repositories."""
-        from vds_git_orchestrator import orchestrate_repositories as pkg_func
-        from vds_git_orchestrator.orchestrator import orchestrate_repositories as mod_func
-
-        assert pkg_func is mod_func
-
-
-class TestBasicFunctionality:
-    """Test basic functionality using package-level imports."""
-
-    def test_create_repository_from_package_import(self, tmp_path: Path) -> None:
-        """Verify Repository can be instantiated using package import."""
-        from vds_git_orchestrator import Repository
-
-        repo = Repository(
-            name="test-repo",
-            path=tmp_path / "test-repo",
-            project="insurance",
-            branch="release",
-            tags={"core", "backend"},
-        )
-
-        assert repo.name == "test-repo"
-        assert repo.project == "insurance"
-        assert repo.branch == "release"
-        assert repo.tags == {"core", "backend"}
-
-    def test_create_manifest_from_package_import(self, tmp_path: Path) -> None:
-        """Verify Manifest can be instantiated using package import."""
-        from vds_git_orchestrator import Manifest, Repository
-
-        repo = Repository(
-            name="test-repo",
-            path=tmp_path / "test-repo",
-            project="insurance",
-            branch="release",
-        )
-        manifest = Manifest(repositories=[repo])
-
-        assert len(manifest.repositories) == 1
-        assert manifest.repositories[0].name == "test-repo"
-
-    def test_filter_manifest_from_package_import(self, tmp_path: Path) -> None:
-        """Verify ManifestFilters works with package imports."""
-        from vds_git_orchestrator import Manifest, ManifestFilters, Repository
-
-        repos = [
-            Repository(
-                name="service-a",
-                path=tmp_path / "service-a",
-                project="insurance",
-                branch="release",
-            ),
-            Repository(
-                name="service-b",
-                path=tmp_path / "service-b",
-                project="lep",
-                branch="release",
-            ),
-        ]
-        manifest = Manifest(repositories=repos)
-        filters = ManifestFilters(project="insurance")
-
-        filtered = manifest.filter(filters)
-
-        assert len(filtered) == 1
-        assert filtered[0].name == "service-a"
-
-    def test_git_operation_enum_from_package_import(self) -> None:
-        """Verify GitOperation enum works with package import."""
-        from vds_git_orchestrator import GitOperation
-
-        assert GitOperation.PULL.value == "pull"
-        assert GitOperation.FETCH.value == "fetch"
-        assert GitOperation.CLONE.value == "clone"
-        assert GitOperation.STATUS.value == "status"

package/skills/vds-skill/vds-scripts/git_orchestrator/tests/test_resilience.py

@@ -1,343 +0,0 @@
-import asyncio
-from pathlib import Path
-
-import pytest
-from vds_git_orchestrator import orchestrator as orchestrator_module
-from vds_git_orchestrator.manifest import Manifest, ManifestFilters, Repository
-from vds_git_orchestrator.orchestrator import GitOperation, orchestrate_repositories
-
-
-@pytest.mark.parametrize(
-    "message",
-    [
-        "fatal: bad object 1234",
-        "error: invalid index-pack output",
-        "pack has 3 unresolved deltas",
-        "reference is not a tree: deadbeef",
-        "object file is empty",
-        "loose object 1234 is corrupt",
-        "missing necessary objects",
-        "fatal: fetch-pack: invalid index-pack output",
-        "could not parse commit 1234",
-        "index file corrupt",
-        "broken link from 1234 to 5678",
-        "directory exists but is not a git repository",
-    ],
-)
-def test_is_corruption_error_detects_patterns(message: str) -> None:
-    assert orchestrator_module._is_corruption_error(message) is True
-
-
-@pytest.mark.parametrize(
-    "message",
-    [
-        "Could not read from remote repository.",
-        "fatal: Authentication failed",
-        "fatal: repository not found",
-    ],
-)
-def test_is_corruption_error_ignores_non_corruption(message: str) -> None:
-    assert orchestrator_module._is_corruption_error(message) is False
-
-
-def test_is_local_workspace_repo_detects_local_project(tmp_path: Path) -> None:
-    repo = Repository(
-        name="local-repo",
-        path=tmp_path / "local-repo",
-        project="local",
-        branch="main",
-        tags=set(),
-    )
-    assert orchestrator_module._is_local_workspace_repo(repo) is True
-
-
-def test_is_local_workspace_repo_detects_local_tag(tmp_path: Path) -> None:
-    repo = Repository(
-        name="tagged-local-repo",
-        path=tmp_path / "tagged-local-repo",
-        project="insurance",
-        branch="main",
-        tags={"local"},
-    )
-    assert orchestrator_module._is_local_workspace_repo(repo) is True
-
-
-@pytest.mark.asyncio
-async def test_pull_repo_recovery_retries_once(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="corrupt-repo",
-        path=tmp_path / "corrupt-repo",
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    run_calls: list[list[str]] = []
-    recover_calls: list[str] = []
-
-    async def fake_run_git(target_repo: Repository, args: list[str]):  # type: ignore[no-untyped-def]
-        # Non-pull commands (e.g. rev-parse for upstream tracking) should succeed silently
-        if args and args[0] != "pull":
-            return 0, "", ""
-        run_calls.append(args)
-        if len(run_calls) == 1:
-            return 1, "", "fatal: bad object"
-        return 0, "Fast-forward", ""
-
-    async def fake_recover_repo(target_repo: Repository, run_id: str):  # type: ignore[no-untyped-def]
-        recover_calls.append(target_repo.name)
-        return True, "recovered"
-
-    monkeypatch.setattr(orchestrator_module, "_run_git", fake_run_git)
-    monkeypatch.setattr(orchestrator_module, "_recover_repo", fake_recover_repo)
-
-    result = await orchestrator_module._pull_repo(repo, dry_run=False, run_id="run")
-
-    assert result.success is True
-    assert len(run_calls) == 2
-    assert recover_calls == ["corrupt-repo"]
-
-
-@pytest.mark.asyncio
-async def test_pull_repo_local_repo_skips_destructive_recovery(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="local-repo",
-        path=tmp_path / "local-repo",
-        project="local",
-        branch="main",
-        tags={"local"},
-    )
-
-    async def fake_run_git(target_repo: Repository, args: list[str]):  # type: ignore[no-untyped-def]
-        return 1, "", "Directory exists but is not a git repository"
-
-    async def fail_recover_repo(*args, **kwargs):  # type: ignore[no-untyped-def]
-        raise AssertionError("local sync must not trigger destructive recovery")
-
-    monkeypatch.setattr(orchestrator_module, "_run_git", fake_run_git)
-    monkeypatch.setattr(orchestrator_module, "_recover_repo", fail_recover_repo)
-
-    result = await orchestrator_module._pull_repo(repo, dry_run=False, run_id="run")
-
-    assert result.success is False
-    assert "not a git repository" in (result.message or "").lower()
-
-
-@pytest.mark.asyncio
-async def test_pull_repo_dry_run_skips_recovery(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="dry-repo",
-        path=tmp_path / "dry-repo",
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    async def fail_call(*args, **kwargs):  # type: ignore[no-untyped-def]
-        raise AssertionError("dry-run should not invoke git or recovery")
-
-    monkeypatch.setattr(orchestrator_module, "_run_git", fail_call)
-    monkeypatch.setattr(orchestrator_module, "_recover_repo", fail_call)
-
-    result = await orchestrator_module._pull_repo(repo, dry_run=True, run_id="dry")
-
-    assert result.success is True
-    assert result.message == "dry-run"
-
-
-class _FakeProcess:
-    def __init__(self, returncode: int, stderr: bytes) -> None:
-        self.returncode = returncode
-        self._stderr = stderr
-
-    async def communicate(self) -> tuple[bytes, bytes]:
-        return b"", self._stderr
-
-
-@pytest.mark.asyncio
-async def test_verify_credentials_raises_on_401(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="auth-repo",
-        path=tmp_path / "auth-repo",
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    async def fake_create_subprocess_exec(*args, **kwargs):  # type: ignore[no-untyped-def]
-        return _FakeProcess(1, b"HTTP 401 Unauthorized")
-
-    monkeypatch.setattr(asyncio, "create_subprocess_exec", fake_create_subprocess_exec)
-
-    with pytest.raises(RuntimeError, match="Authentication failed"):
-        await orchestrator_module._verify_credentials(repo)
-
-
-@pytest.mark.asyncio
-async def test_verify_credentials_raises_on_403(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="auth-repo",
-        path=tmp_path / "auth-repo",
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    async def fake_create_subprocess_exec(*args, **kwargs):  # type: ignore[no-untyped-def]
-        return _FakeProcess(1, b"403 Forbidden")
-
-    monkeypatch.setattr(asyncio, "create_subprocess_exec", fake_create_subprocess_exec)
-
-    with pytest.raises(RuntimeError, match="Authentication failed"):
-        await orchestrator_module._verify_credentials(repo)
-
-
-@pytest.mark.asyncio
-async def test_orchestrate_preflight_aborts_on_auth_error(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="auth-preflight",
-        path=tmp_path / "auth-preflight",
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    manifest = Manifest([repo])
-
-    async def fake_check_network(*args, **kwargs):  # type: ignore[no-untyped-def]
-        return True, "ok"
-
-    async def fake_verify_credentials(*args, **kwargs):  # type: ignore[no-untyped-def]
-        raise RuntimeError("Authentication failed for http://example")
-
-    async def fail_pre_clone(*args, **kwargs):  # type: ignore[no-untyped-def]
-        raise AssertionError("pre-clone should not run after auth failure")
-
-    monkeypatch.setattr(orchestrator_module, "_check_network_connectivity", fake_check_network)
-    monkeypatch.setattr(orchestrator_module, "_verify_credentials", fake_verify_credentials)
-    monkeypatch.setattr(orchestrator_module, "_ensure_all_repos_cloned", fail_pre_clone)
-
-    with pytest.raises(RuntimeError, match="Authentication failed"):
-        await orchestrate_repositories(
-            manifest=manifest,
-            operation=GitOperation.PULL,
-            filters=ManifestFilters(),
-            concurrency=1,
-            dry_run=False,
-            run_id="auth",
-            retries=0,
-        )
-
-
-@pytest.mark.asyncio
-async def test_run_git_executes_once_without_retry(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo_path = tmp_path / "repo"
-    (repo_path / ".git").mkdir(parents=True)
-    repo = Repository(
-        name="single-call",
-        path=repo_path,
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    calls: list[list[str]] = []
-
-    async def fake_run_process(command: list[str], cwd: Path):  # type: ignore[no-untyped-def]
-        calls.append(command)
-        return 0, "ok", ""
-
-    monkeypatch.setattr(orchestrator_module, "_run_process", fake_run_process)
-
-    returncode, stdout, stderr = await orchestrator_module._run_git(repo, ["status", "--short"])
-
-    assert returncode == 0
-    assert stdout == "ok"
-    assert stderr == ""
-    assert len(calls) == 1
-
-
-@pytest.mark.asyncio
-async def test_run_git_retries_once_after_index_lock(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo_path = tmp_path / "repo"
-    git_dir = repo_path / ".git"
-    git_dir.mkdir(parents=True)
-    lock_path = git_dir / "index.lock"
-    lock_path.write_text("stale lock", encoding="utf-8")
-
-    repo = Repository(
-        name="lock-retry",
-        path=repo_path,
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    attempts = 0
-
-    async def fake_run_process(command: list[str], cwd: Path):  # type: ignore[no-untyped-def]
-        nonlocal attempts
-        attempts += 1
-        if attempts == 1:
-            message = f"error: Unable to create '{lock_path}': File exists."
-            return 1, "", message
-        return 0, "ok", ""
-
-    monkeypatch.setattr(orchestrator_module, "_run_process", fake_run_process)
-
-    returncode, stdout, stderr = await orchestrator_module._run_git(repo, ["status", "--short"])
-
-    assert attempts == 2
-    assert returncode == 0
-    assert stdout == "ok"
-    assert stderr == ""
-    assert lock_path.exists() is False
-
-
-@pytest.mark.asyncio
-async def test_pull_repo_overwrite_local_with_remote(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    repo = Repository(
-        name="force-sync",
-        path=tmp_path / "force-sync",
-        project="insurance",
-        branch="release",
-        tags=set(),
-    )
-
-    rev_parse_calls = 0
-    commands: list[list[str]] = []
-
-    async def fake_run_git(target_repo: Repository, args: list[str]):  # type: ignore[no-untyped-def]
-        nonlocal rev_parse_calls
-        commands.append(args)
-
-        if args == ["fetch", "--all", "--prune"]:
-            return 0, "", ""
-        if args == ["show-ref", "--verify", "refs/remotes/origin/release"]:
-            return 0, "refs/remotes/origin/release", ""
-        if args == ["rev-parse", "HEAD"]:
-            rev_parse_calls += 1
-            if rev_parse_calls == 1:
-                return 0, "abc123\n", ""
-            return 0, "def456\n", ""
-        if args == ["checkout", "-B", "release", "origin/release"]:
-            return 0, "Switched to and reset branch 'release'", ""
-        if args == ["reset", "--hard", "origin/release"]:
-            return 0, "HEAD is now at def456 sync", ""
-        return 1, "", f"unexpected args: {args}"
-
-    monkeypatch.setattr(orchestrator_module, "_run_git", fake_run_git)
-
-    result = await orchestrator_module._pull_repo(
-        repo,
-        dry_run=False,
-        run_id="force-sync",
-        overwrite_local_with_remote=True,
-    )
-
-    assert result.success is True
-    assert result.updated is True
-    assert "overwrite-local enabled" in (result.message or "")
-    assert ["fetch", "--all", "--prune"] in commands
-    assert ["checkout", "-B", "release", "origin/release"] in commands
-    assert ["reset", "--hard", "origin/release"] in commands