core-framework 0.12.7__py3-none-any.whl → 0.12.9__py3-none-any.whl

core/__init__.py

@@ -278,7 +278,7 @@ from core.exceptions import (
     MissingDependency,
 )
 
-__version__ = "0.12.7"
+__version__ = "0.12.9"
 __all__ = [
     # Models
     "Model",

core/cli/__init__.py

@@ -10,6 +10,8 @@ Comandos disponíveis:
 - core run: Executa o servidor de desenvolvimento
 - core shell: Abre shell interativo
 - core routes: Lista rotas registradas
+- core test: Executa testes com ambiente isolado
+- core version: Mostra versão do framework
 """
 
 from core.cli.main import cli, main

core/cli/main.py

@@ -13,7 +13,16 @@ Comandos:
     run             Executa servidor de desenvolvimento
     shell           Abre shell interativo async
     routes          Lista rotas registradas
+    test            Executa testes com ambiente isolado
     version         Mostra versão do framework
+
+Comando test:
+    core test                       # Roda todos os testes em tests/
+    core test tests/test_auth.py    # Roda arquivo específico
+    core test -v                    # Saída verbosa
+    core test --cov                 # Com cobertura de código
+    core test -k "test_login"       # Filtrar por keyword
+    core test -m unit               # Apenas testes unitários
 """
 
 from __future__ import annotations
@@ -472,6 +481,112 @@ def cmd_version(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_test(args: argparse.Namespace) -> int:
+    """
+    Run tests with auto-discovery and isolated environment.
+    
+    This command:
+    - Automatically sets up an isolated test environment
+    - Initializes database with in-memory SQLite
+    - Configures auth, settings, and middleware
+    - Runs pytest with appropriate options
+    - Supports coverage reporting
+    
+    Usage:
+        core test                    # Run all tests in tests/
+        core test tests/test_auth.py # Run specific file
+        core test -v                 # Verbose output
+        core test --cov              # With coverage
+        core test -k "test_login"    # Filter by keyword
+        core test -m unit            # Only unit tests
+    """
+    import subprocess
+    import shutil
+    
+    # Check if pytest is installed
+    pytest_path = shutil.which("pytest")
+    if not pytest_path:
+        print(error("pytest not installed. Install with:"))
+        print(info("  pip install pytest pytest-asyncio"))
+        return 1
+    
+    print(bold("🧪 Core Framework Test Runner"))
+    print()
+    
+    # Build pytest command
+    cmd = ["python", "-m", "pytest"]
+    
+    # Add test path
+    cmd.append(args.path)
+    
+    # Verbose
+    if args.verbose:
+        cmd.append("-v")
+    
+    # Keyword filter
+    if args.keyword:
+        cmd.extend(["-k", args.keyword])
+    
+    # Exit on first failure
+    if args.exitfirst:
+        cmd.append("-x")
+    
+    # Marker filter
+    if args.marker:
+        cmd.extend(["-m", args.marker])
+    
+    # No header
+    if args.no_header:
+        cmd.append("--no-header")
+    
+    # Coverage
+    if args.cov:
+        # Check if pytest-cov is installed
+        if not shutil.which("pytest-cov") and not _check_pytest_cov():
+            print(warning("pytest-cov not installed. Install with:"))
+            print(info("  pip install pytest-cov"))
+            print()
+        
+        cmd.append(f"--cov={args.cov}")
+        cmd.append(f"--cov-report={args.cov_report}")
+    
+    # Always use asyncio mode auto
+    cmd.extend(["--asyncio-mode=auto"])
+    
+    # Show short traceback
+    cmd.append("--tb=short")
+    
+    print(info(f"Running: {' '.join(cmd)}"))
+    print()
+    
+    # Set environment variables for isolated testing
+    env = os.environ.copy()
+    env["TESTING"] = "true"
+    env["DEBUG"] = "true"
+    env.setdefault("DATABASE_URL", "sqlite+aiosqlite:///:memory:")
+    env.setdefault("SECRET_KEY", "test-secret-key-for-testing-only")
+    
+    # Run pytest
+    try:
+        result = subprocess.run(cmd, env=env)
+        return result.returncode
+    except KeyboardInterrupt:
+        print(warning("\nTests interrupted"))
+        return 130
+    except Exception as e:
+        print(error(f"Error running tests: {e}"))
+        return 1
+
+
+def _check_pytest_cov() -> bool:
+    """Check if pytest-cov is installed as a module."""
+    try:
+        import pytest_cov
+        return True
+    except ImportError:
+        return False
+
+
 def check_uv_installed() -> bool:
     """Verifica se uv está instalado."""
     import shutil
@@ -3747,6 +3862,54 @@ For more information, visit: https://github.com/SorPuti/core-framework
     )
     tasks_parser.set_defaults(func=cmd_tasks)
     
+    # test
+    test_parser = subparsers.add_parser(
+        "test",
+        help="Run tests with auto-discovery and isolated environment"
+    )
+    test_parser.add_argument(
+        "path",
+        nargs="?",
+        default="tests",
+        help="Test path or file (default: tests)"
+    )
+    test_parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Verbose output"
+    )
+    test_parser.add_argument(
+        "-k", "--keyword",
+        help="Only run tests matching keyword expression"
+    )
+    test_parser.add_argument(
+        "-x", "--exitfirst",
+        action="store_true",
+        help="Exit on first failure"
+    )
+    test_parser.add_argument(
+        "--cov",
+        nargs="?",
+        const=".",
+        help="Enable coverage (optionally specify source)"
+    )
+    test_parser.add_argument(
+        "--cov-report",
+        choices=["term", "html", "xml", "json"],
+        default="term",
+        help="Coverage report format"
+    )
+    test_parser.add_argument(
+        "-m", "--marker",
+        help="Only run tests with this marker (e.g., 'unit', 'integration')"
+    )
+    test_parser.add_argument(
+        "--no-header",
+        action="store_true",
+        help="Disable pytest header"
+    )
+    test_parser.set_defaults(func=cmd_test)
+    
     return parser
 
 

core/testing/__init__.py

@@ -0,0 +1,99 @@
+"""
+Testing utilities for core-framework applications.
+
+This module provides a complete testing toolkit for applications built
+with core-framework, including:
+
+- TestClient: HTTP client with automatic test database setup
+- AuthenticatedClient: Pre-authenticated HTTP client
+- TestDatabase: Database utilities for testing
+- MockKafka, MockRedis, MockHTTP: Mock services
+- Factory: Data factory pattern for test data generation
+
+Usage:
+    # In your conftest.py
+    import pytest
+    from your_app import app as _app
+    
+    @pytest.fixture(scope="session")
+    def app():
+        return _app.app
+    
+    # In your tests
+    class TestUsers:
+        async def test_register(self, client):
+            response = await client.post("/auth/register", json={...})
+            assert response.status_code == 201
+        
+        async def test_profile(self, auth_client):
+            response = await auth_client.get("/auth/me")
+            assert response.status_code == 200
+
+Quick Start:
+    1. Install test dependencies: pip install core-framework[testing]
+    2. Add to pyproject.toml:
+       [tool.pytest.ini_options]
+       asyncio_mode = "auto"
+       plugins = ["core.testing.plugin"]
+    3. Create conftest.py with your app fixture
+    4. Write tests using provided fixtures
+"""
+
+from core.testing.client import (
+    TestClient,
+    AuthenticatedClient,
+    create_test_client,
+    create_auth_client,
+)
+from core.testing.database import (
+    TestDatabase,
+    setup_test_db,
+    teardown_test_db,
+    get_test_session,
+)
+from core.testing.mocks import (
+    MockKafka,
+    MockRedis,
+    MockHTTP,
+    MockMessage,
+    MockHTTPResponse,
+)
+from core.testing.factories import (
+    Factory,
+    UserFactory,
+    fake,
+)
+from core.testing.assertions import (
+    assert_status,
+    assert_json_contains,
+    assert_error_code,
+    assert_validation_error,
+)
+
+__all__ = [
+    # Client
+    "TestClient",
+    "AuthenticatedClient",
+    "create_test_client",
+    "create_auth_client",
+    # Database
+    "TestDatabase",
+    "setup_test_db",
+    "teardown_test_db",
+    "get_test_session",
+    # Mocks
+    "MockKafka",
+    "MockRedis",
+    "MockHTTP",
+    "MockMessage",
+    "MockHTTPResponse",
+    # Factories
+    "Factory",
+    "UserFactory",
+    "fake",
+    # Assertions
+    "assert_status",
+    "assert_json_contains",
+    "assert_error_code",
+    "assert_validation_error",
+]

core/testing/assertions.py

@@ -0,0 +1,347 @@
+"""
+Custom assertions for API testing.
+
+Provides helper functions for common test assertions.
+
+Usage:
+    response = await client.get("/users/1")
+    
+    assert_status(response, 200)
+    assert_json_contains(response, {"email": "test@example.com"})
+    assert_error_code(response, "not_found")
+"""
+
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from httpx import Response
+
+
+def assert_status(response: "Response", expected: int, msg: str = "") -> None:
+    """
+    Assert response has expected status code.
+    
+    Args:
+        response: HTTP response
+        expected: Expected status code
+        msg: Optional message
+        
+    Raises:
+        AssertionError: If status doesn't match
+        
+    Example:
+        assert_status(response, 200)
+        assert_status(response, 201, "User should be created")
+    """
+    actual = response.status_code
+    if actual != expected:
+        body = _safe_json(response)
+        error_msg = f"Expected status {expected}, got {actual}. Response: {body}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+
+
+def assert_status_ok(response: "Response", msg: str = "") -> None:
+    """Assert response is 2xx."""
+    if not 200 <= response.status_code < 300:
+        body = _safe_json(response)
+        error_msg = f"Expected 2xx status, got {response.status_code}. Response: {body}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+
+
+def assert_status_error(response: "Response", msg: str = "") -> None:
+    """Assert response is 4xx or 5xx."""
+    if response.status_code < 400:
+        body = _safe_json(response)
+        error_msg = f"Expected error status, got {response.status_code}. Response: {body}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+
+
+def assert_json_contains(
+    response: "Response",
+    expected: dict[str, Any],
+    msg: str = "",
+) -> None:
+    """
+    Assert response JSON contains expected fields.
+    
+    Args:
+        response: HTTP response
+        expected: Dict of expected fields and values
+        msg: Optional message
+        
+    Raises:
+        AssertionError: If fields don't match
+        
+    Example:
+        assert_json_contains(response, {"email": "test@example.com"})
+        assert_json_contains(response, {"status": "active", "role": "admin"})
+    """
+    actual = _safe_json(response)
+    
+    if not isinstance(actual, dict):
+        raise AssertionError(
+            f"Expected JSON object, got {type(actual).__name__}: {actual}"
+        )
+    
+    for key, value in expected.items():
+        if key not in actual:
+            error_msg = f"Missing key '{key}' in response. Response: {actual}"
+            if msg:
+                error_msg = f"{msg}. {error_msg}"
+            raise AssertionError(error_msg)
+        
+        if actual[key] != value:
+            error_msg = (
+                f"Value mismatch for '{key}': expected {value!r}, "
+                f"got {actual[key]!r}. Response: {actual}"
+            )
+            if msg:
+                error_msg = f"{msg}. {error_msg}"
+            raise AssertionError(error_msg)
+
+
+def assert_json_equals(
+    response: "Response",
+    expected: dict[str, Any] | list[Any],
+    msg: str = "",
+) -> None:
+    """
+    Assert response JSON equals expected exactly.
+    
+    Args:
+        response: HTTP response
+        expected: Expected JSON value
+        msg: Optional message
+    """
+    actual = _safe_json(response)
+    
+    if actual != expected:
+        error_msg = f"JSON mismatch. Expected: {expected}. Got: {actual}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+
+
+def assert_json_list(
+    response: "Response",
+    min_length: int = 0,
+    max_length: int | None = None,
+    msg: str = "",
+) -> list[Any]:
+    """
+    Assert response is a JSON list and return it.
+    
+    Args:
+        response: HTTP response
+        min_length: Minimum list length
+        max_length: Maximum list length (None = no limit)
+        msg: Optional message
+        
+    Returns:
+        The response JSON list
+    """
+    actual = _safe_json(response)
+    
+    if not isinstance(actual, list):
+        raise AssertionError(
+            f"Expected JSON list, got {type(actual).__name__}: {actual}"
+        )
+    
+    if len(actual) < min_length:
+        error_msg = f"List too short: expected at least {min_length}, got {len(actual)}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+    
+    if max_length is not None and len(actual) > max_length:
+        error_msg = f"List too long: expected at most {max_length}, got {len(actual)}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+    
+    return actual
+
+
+def assert_error_code(
+    response: "Response",
+    code: str,
+    msg: str = "",
+) -> None:
+    """
+    Assert response contains specific error code.
+    
+    Looks for code in: detail.code, code, error.code
+    
+    Args:
+        response: HTTP response
+        code: Expected error code
+        msg: Optional message
+        
+    Example:
+        assert_error_code(response, "not_found")
+        assert_error_code(response, "validation_error")
+    """
+    actual = _safe_json(response)
+    
+    if not isinstance(actual, dict):
+        raise AssertionError(f"Expected JSON object, got: {actual}")
+    
+    # Try different locations for error code
+    actual_code = (
+        actual.get("code") or
+        (actual.get("detail", {}).get("code") if isinstance(actual.get("detail"), dict) else None) or
+        actual.get("error", {}).get("code") if isinstance(actual.get("error"), dict) else None
+    )
+    
+    if actual_code != code:
+        error_msg = f"Expected error code '{code}', got '{actual_code}'. Response: {actual}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+
+
+def assert_validation_error(
+    response: "Response",
+    field: str | None = None,
+    msg: str = "",
+) -> None:
+    """
+    Assert response is a validation error.
+    
+    Args:
+        response: HTTP response
+        field: Optional field that should have error
+        msg: Optional message
+        
+    Example:
+        assert_validation_error(response)
+        assert_validation_error(response, field="email")
+    """
+    if response.status_code != 422:
+        raise AssertionError(
+            f"Expected 422 validation error, got {response.status_code}. "
+            f"Response: {_safe_json(response)}"
+        )
+    
+    if field is not None:
+        actual = _safe_json(response)
+        
+        # Look for field in various error formats
+        found = False
+        
+        # FastAPI format: detail[].loc
+        detail = actual.get("detail", [])
+        if isinstance(detail, list):
+            for error in detail:
+                loc = error.get("loc", [])
+                if field in loc or (len(loc) > 1 and loc[-1] == field):
+                    found = True
+                    break
+        
+        # Our format: errors[].field
+        errors = actual.get("errors", [])
+        if isinstance(errors, list):
+            for error in errors:
+                if error.get("field") == field:
+                    found = True
+                    break
+        
+        if not found:
+            error_msg = f"Expected validation error for field '{field}'. Response: {actual}"
+            if msg:
+                error_msg = f"{msg}. {error_msg}"
+            raise AssertionError(error_msg)
+
+
+def assert_header(
+    response: "Response",
+    header: str,
+    expected: str | None = None,
+    msg: str = "",
+) -> str | None:
+    """
+    Assert response has header, optionally with specific value.
+    
+    Args:
+        response: HTTP response
+        header: Header name
+        expected: Expected value (None = just check exists)
+        msg: Optional message
+        
+    Returns:
+        Header value
+    """
+    actual = response.headers.get(header)
+    
+    if actual is None:
+        error_msg = f"Missing header '{header}'. Headers: {dict(response.headers)}"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+    
+    if expected is not None and actual != expected:
+        error_msg = f"Header '{header}' mismatch: expected '{expected}', got '{actual}'"
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+    
+    return actual
+
+
+def assert_no_error(response: "Response", msg: str = "") -> None:
+    """
+    Assert response is not an error (2xx status).
+    
+    Provides detailed error message on failure.
+    """
+    if response.status_code >= 400:
+        body = _safe_json(response)
+        error_msg = (
+            f"Request failed with {response.status_code}. "
+            f"Response: {body}"
+        )
+        if msg:
+            error_msg = f"{msg}. {error_msg}"
+        raise AssertionError(error_msg)
+
+
+def assert_created(response: "Response", msg: str = "") -> dict[str, Any]:
+    """
+    Assert response is 201 Created and return JSON body.
+    
+    Returns:
+        Response JSON
+    """
+    assert_status(response, 201, msg)
+    return _safe_json(response)
+
+
+def assert_not_found(response: "Response", msg: str = "") -> None:
+    """Assert response is 404 Not Found."""
+    assert_status(response, 404, msg)
+
+
+def assert_unauthorized(response: "Response", msg: str = "") -> None:
+    """Assert response is 401 Unauthorized."""
+    assert_status(response, 401, msg)
+
+
+def assert_forbidden(response: "Response", msg: str = "") -> None:
+    """Assert response is 403 Forbidden."""
+    assert_status(response, 403, msg)
+
+
+def _safe_json(response: "Response") -> Any:
+    """Safely get JSON from response."""
+    try:
+        return response.json()
+    except Exception:
+        return response.text