┌─────────────────────────────────────────────────────────────┐
│                       MyService                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │ def __init__(                                        │    │
│  │     self,                                            │    │
│  │     client: Optional[ClientProtocol] = None          │    │
│  │ ):                                                   │    │
│  │     self.client = client or DefaultClient()          │    │
│  └─────────────────────────────────────────────────────┘    │
└───────────────────────────┬─────────────────────────────────┘
                            │
                ┌───────────┴───────────┐
                │                       │
        ┌───────▼───────┐       ┌───────▼───────┐
        │ DefaultClient │       │  MockClient   │
        │ (production)  │       │  (testing)    │
        └───────────────┘       └───────────────┘

from typing import Optional, Protocol


class GitHubClient(Protocol):
    """Protocol for GitHub API operations.

    Allows for dependency injection and testing.
    """

    def check_auth(self) -> bool:
        """Check if authenticated with GitHub."""
        ...

    def check_repo_access(self, repo: str) -> bool:
        """Check if user has access to a repository."""
        ...

    def fetch_file(self, repo: str, path: str) -> Optional[str]:
        """Fetch a file's content from a repository."""
        ...

import subprocess
from typing import Optional


class DefaultGitHubClient:
    """Default GitHub client using gh CLI."""

    def check_auth(self) -> bool:
        """Check if GitHub CLI is authenticated."""
        try:
            result = subprocess.run(
                ["gh", "auth", "status"],
                capture_output=True,
                text=True,
            )
            return result.returncode == 0
        except FileNotFoundError:
            return False

    def check_repo_access(self, repo: str) -> bool:
        """Check if user has access to the repository."""
        result = subprocess.run(
            ["gh", "api", f"/repos/{repo}", "--silent"],
            capture_output=True,
        )
        return result.returncode == 0

    def fetch_file(self, repo: str, path: str) -> Optional[str]:
        """Fetch a file's content from a repository."""
        try:
            result = subprocess.run(
                [
                    "gh", "api",
                    f"/repos/{repo}/contents/{path}",
                    "-H", "Accept: application/vnd.github.raw+json",
                ],
                capture_output=True,
                text=True,
                check=True,
            )
            return result.stdout
        except subprocess.CalledProcessError:
            return None

from typing import List, Optional

from context_harness.primitives import (
    ErrorCode,
    Failure,
    Result,
    Skill,
    Success,
)


class SkillService:
    """Service for managing skills.

    Example:
        # Production usage (default client)
        service = SkillService()

        # Testing usage (mock client)
        mock_client = MockGitHubClient(authenticated=False)
        service = SkillService(github_client=mock_client)
    """

    def __init__(
        self,
        github_client: Optional[GitHubClient] = None,
        skills_repo: str = "org/skills-repo",
    ):
        """Initialize the skill service.

        Args:
            github_client: GitHub client for API operations
            skills_repo: Skills repository (owner/repo format)
        """
        self.github = github_client or DefaultGitHubClient()
        self.skills_repo = skills_repo

    def list_remote(self) -> Result[List[Skill]]:
        """List available skills from remote registry."""
        # Use self.github - works with either real or mock client
        if not self.github.check_auth():
            return Failure(
                error="GitHub CLI is not authenticated",
                code=ErrorCode.AUTH_REQUIRED,
            )

        # ... rest of implementation

from typing import Optional


class MockGitHubClient:
    """Mock GitHub client for testing."""

    def __init__(
        self,
        authenticated: bool = True,
        has_repo_access: bool = True,
        registry_content: Optional[str] = None,
        username: str = "test-user",
    ):
        """Initialize mock with controllable behavior.

        Args:
            authenticated: Whether check_auth() returns True
            has_repo_access: Whether check_repo_access() returns True
            registry_content: Content to return from fetch_file
            username: Username to return from get_username
        """
        self._authenticated = authenticated
        self._has_repo_access = has_repo_access
        self._registry_content = registry_content
        self._username = username
        self._files: dict[str, str] = {}

    def check_auth(self) -> bool:
        return self._authenticated

    def check_repo_access(self, repo: str) -> bool:
        return self._has_repo_access

    def fetch_file(self, repo: str, path: str) -> Optional[str]:
        if path == "skills.json":
            return self._registry_content
        return self._files.get(path)

import pytest
from context_harness.primitives import ErrorCode, Failure, Success
from context_harness.services.skill_service import SkillService


class TestSkillServiceListRemote:
    """Tests for SkillService.list_remote()."""

    def test_list_remote_returns_skills(self) -> None:
        """Test listing remote skills returns skills from registry."""
        registry = '{"skills": [{"name": "skill-a"}]}'
        client = MockGitHubClient(registry_content=registry)
        service = SkillService(github_client=client)

        result = service.list_remote()

        assert isinstance(result, Success)
        assert len(result.value) == 1
        assert result.value[0].name == "skill-a"

    def test_list_remote_not_authenticated(self) -> None:
        """Test list_remote fails when not authenticated."""
        client = MockGitHubClient(authenticated=False)
        service = SkillService(github_client=client)

        result = service.list_remote()

        assert isinstance(result, Failure)
        assert result.code == ErrorCode.AUTH_REQUIRED

# BAD: Can't test without calling GitHub
class SkillService:
    def __init__(self):
        self.github = DefaultGitHubClient()  # No way to override!

# BAD: Test depends on actual protocol
def test_list_remote():
    service = SkillService()  # Uses real GitHub client!
    result = service.list_remote()