Test generated code: 4 chiến lược cho code mà không ai viết tay

# ✅ Test generator behavior
def test_list_method_generates_pagination():
    """Mọi list method phải có pagination logic."""
    generated = run_generator_for_method(list_method_fixture)
    assert "has_next_page" in generated.adapter_code
    assert "Iterator" in generated.adapter_code
 
# ❌ Test specific generated output (fragile, scales poorly)
def test_user_adapter_exact_content():
    content = open("generated/adapters/user_adapter.py").read()
    assert content == EXACT_EXPECTED_STRING  # Breaks on any whitespace change

# tests/test_snapshots.py
import pytest
from pathlib import Path
from pipeline.generator import render_adapter, render_command
 
 
SNAPSHOTS_DIR = Path("tests/snapshots")
UPDATE_SNAPSHOTS = False  # Set True để update golden files
 
 
def assert_snapshot(name: str, actual: str):
    snapshot_file = SNAPSHOTS_DIR / f"{name}.py"
 
    if UPDATE_SNAPSHOTS or not snapshot_file.exists():
        SNAPSHOTS_DIR.mkdir(parents=True, exist_ok=True)
        snapshot_file.write_text(actual)
        pytest.skip(f"Snapshot created: {name}")
    else:
        expected = snapshot_file.read_text()
        assert actual == expected, (
            f"Snapshot mismatch for {name}.\n"
            f"Run with UPDATE_SNAPSHOTS=True to update.\n"
            f"Diff:\n{unified_diff(expected, actual)}"
        )
 
 
def unified_diff(expected: str, actual: str) -> str:
    import difflib
    return "\n".join(difflib.unified_diff(
        expected.splitlines(), actual.splitlines(),
        lineterm="", fromfile="expected", tofile="actual"
    ))
 
 
SIMPLE_LIST_METHOD = {
    "id": "user.list",
    "resource": "user",
    "action": "list",
    "cli_command": "list-users",
    "http_method": "GET",
    "path": "/users",
    "summary": "List all users",
    "description": "",
    "parameters": [
        {"name": "role", "in": "query", "type": "string", "required": False, "description": "Filter by role"}
    ],
    "paginated": True,
    "idempotent": True,
    "requires_auth": True,
    "tags": ["users"],
}
 
 
def test_adapter_snapshot_simple_list():
    """Simple list method adapter matches golden file."""
    code = render_adapter_to_string("user", [SIMPLE_LIST_METHOD])
    assert_snapshot("adapter_simple_list", code)
 
 
def test_command_snapshot_has_json_flag():
    """Command snapshot includes --json flag."""
    code = render_command_to_string("user", [SIMPLE_LIST_METHOD])
    assert_snapshot("command_simple_list", code)
    # Also verify critical property
    assert "--json" in code

# tests/test_contracts.py
import json
import ast
from pathlib import Path
from pipeline.generator import run_pipeline
 
 
def extract_python_functions(code: str) -> list[str]:
    """Parse Python code, return list of function names."""
    tree = ast.parse(code)
    return [
        node.name
        for node in ast.walk(tree)
        if isinstance(node, ast.FunctionDef)
    ]
 
 
def extract_python_classes(code: str) -> list[str]:
    tree = ast.parse(code)
    return [
        node.name
        for node in ast.walk(tree)
        if isinstance(node, ast.ClassDef)
    ]
 
 
class TestAdapterContracts:
    """Verify adapter code satisfies contracts from metadata."""
 
    def setup_method(self):
        self.metadata = json.loads(Path("metadata/api-metadata.json").read_text())
        self.methods = self.metadata["methods"]
        self.generated_dir = Path("generated/")
 
    def test_every_method_has_adapter_implementation(self):
        """Mỗi method trong metadata phải có implementation trong adapter."""
        for method in self.methods:
            resource = method["resource"]
            adapter_file = self.generated_dir / "adapters" / f"{resource}_adapter.py"
            assert adapter_file.exists(), f"Missing adapter for resource: {resource}"
 
            code = adapter_file.read_text()
            expected_func = f"{method['action']}_{resource}"
            functions = extract_python_functions(code)
            assert expected_func in functions, (
                f"Method {method['id']} missing from adapter. "
                f"Expected function: {expected_func}"
            )
 
    def test_every_method_has_cli_command(self):
        """Mỗi method phải có CLI command."""
        for method in self.methods:
            resource = method["resource"]
            command_file = self.generated_dir / "cli" / f"{resource}s.py"
            assert command_file.exists()
 
            code = command_file.read_text()
            cli_command = method["cli_command"]
            # Command decorator: @app.command() trước function với cli_command name
            assert cli_command in code, (
                f"CLI command '{cli_command}' missing from {resource}s.py"
            )
 
    def test_json_flag_present_in_all_commands(self):
        """CRITICAL: Mọi command phải có --json flag (agent-ready requirement)."""
        for command_file in (self.generated_dir / "cli").glob("*.py"):
            code = command_file.read_text()
            # Count command decorators vs json flag occurrences
            command_count = code.count("@app.command()")
            json_flag_count = code.count("--json")
            assert command_count == json_flag_count, (
                f"{command_file.name}: {command_count} commands but {json_flag_count} --json flags. "
                f"Every command must have --json flag."
            )
 
    def test_delete_commands_require_force_flag(self):
        """Destructive commands phải có --force flag."""
        delete_methods = [m for m in self.methods if m["action"] == "delete"]
        for method in delete_methods:
            resource = method["resource"]
            command_file = self.generated_dir / "cli" / f"{resource}s.py"
            code = command_file.read_text()
            assert "--force" in code, (
                f"Delete command for {resource} missing --force flag. "
                f"All destructive operations require explicit confirmation."
            )
 
    def test_exit_codes_defined(self):
        """Mỗi adapter phải define exit codes."""
        for adapter_file in (self.generated_dir / "adapters").glob("*.py"):
            code = adapter_file.read_text()
            assert "AdapterError" in code, (
                f"{adapter_file.name}: Missing AdapterError import/usage"
            )

# tests/unit/test_cli_users.py
import json
from unittest.mock import MagicMock, patch
from typer.testing import CliRunner
from generated.cli.users import app
 
 
runner = CliRunner()
 
 
class TestListUsersCommand:
 
    def test_list_users_text_output(self):
        """Default output là text format."""
        mock_users = [
            MagicMock(id=1, name="Alice", email="a@x.com", role="admin"),
            MagicMock(id=2, name="Bob", email="b@x.com", role="member"),
        ]
        with patch("generated.cli.users.UserAdapter") as MockAdapter:
            MockAdapter.return_value.__enter__.return_value.list_users.return_value = iter(mock_users)
            result = runner.invoke(app, ["list-users"])
 
        assert result.exit_code == 0
        assert "Alice" in result.output
        assert "Bob" in result.output
 
    def test_list_users_json_output(self):
        """--json flag trả về valid JSON."""
        mock_users = [
            MagicMock(id=1, name="Alice", email="a@x.com", role="admin"),
        ]
        with patch("generated.cli.users.UserAdapter") as MockAdapter:
            MockAdapter.return_value.__enter__.return_value.list_users.return_value = iter(mock_users)
            result = runner.invoke(app, ["list-users", "--json"])
 
        assert result.exit_code == 0
        data = json.loads(result.output)
        assert isinstance(data, list)
        assert data[0]["name"] == "Alice"
 
    def test_auth_error_returns_exit_code_4(self):
        """Auth error → exit code 4."""
        from generated.adapters.user_adapter import AdapterError
        with patch("generated.cli.users.UserAdapter") as MockAdapter:
            MockAdapter.return_value.__enter__.return_value.list_users.side_effect = \
                AdapterError("auth", "Invalid token", exit_code=4)
            result = runner.invoke(app, ["list-users", "--json"])
 
        assert result.exit_code == 4
 
    def test_delete_without_force_returns_exit_code_2(self):
        """Delete without --force → usage error (exit code 2)."""
        result = runner.invoke(app, ["delete-user", "42"])
        assert result.exit_code == 2
 
 
class TestDeleteUserCommand:
 
    def test_delete_with_force_succeeds(self):
        """--force flag cho phép delete proceed."""
        with patch("generated.cli.users.UserAdapter") as MockAdapter:
            MockAdapter.return_value.__enter__.return_value.delete_user.return_value = None
            result = runner.invoke(app, ["delete-user", "42", "--force"])
 
        assert result.exit_code == 0

# tests/integration/test_user_adapter.py
import pytest
import respx
import httpx
from generated.adapters.user_adapter import UserAdapter, AdapterError
 
 
BASE_URL = "https://api.example.com/v1"
 
 
@pytest.fixture
def adapter():
    return UserAdapter(token="test-token", base_url=BASE_URL)
 
 
class TestListUsersIntegration:
 
    @respx.mock
    def test_list_handles_pagination(self, adapter):
        """Adapter tự động handle multi-page response."""
        # Page 1
        respx.get(f"{BASE_URL}/users").mock(
            side_effect=[
                httpx.Response(200, json={
                    "items": [{"id": 1, "name": "Alice", "email": "a@x.com", "role": "admin"}],
                    "has_next_page": True
                }),
                # Page 2
                httpx.Response(200, json={
                    "items": [{"id": 2, "name": "Bob", "email": "b@x.com", "role": "member"}],
                    "has_next_page": False
                }),
            ]
        )
 
        users = list(adapter.list_users())
        assert len(users) == 2
        assert users[0].name == "Alice"
        assert users[1].name == "Bob"
 
    @respx.mock
    def test_401_raises_adapter_error_with_exit_code_4(self, adapter):
        respx.get(f"{BASE_URL}/users/999").mock(
            return_value=httpx.Response(401, json={"message": "Unauthorized"})
        )
 
        with pytest.raises(AdapterError) as exc_info:
            adapter.get_user(999)
 
        assert exc_info.value.exit_code == 4
        assert exc_info.value.code == "auth"
 
    @respx.mock
    def test_ensure_user_idempotent(self, adapter):
        """ensure_user gọi 2 lần với cùng email → action = already_exists lần 2."""
        respx.get(f"{BASE_URL}/users").mock(
            side_effect=[
                # First call: not found
                httpx.Response(200, json={"items": [], "has_next_page": False}),
                # create succeeds
            ]
        )
        respx.post(f"{BASE_URL}/users").mock(
            return_value=httpx.Response(201, json={"id": 1, "name": "Alice", "email": "a@x.com", "role": "member"})
        )
 
        user1, action1 = adapter.ensure_user("Alice", "a@x.com")
        assert action1 == "created"