core-framework 0.12.6__tar.gz → 0.12.7__tar.gz

{core_framework-0.12.6 → core_framework-0.12.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.6
+Version: 0.12.7
 Summary: Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema.
 Project-URL: Homepage, https://github.com/SorPuti/core-framework
 Project-URL: Documentation, https://github.com/SorPuti/core-framework#readme

{core_framework-0.12.6 → core_framework-0.12.7}/core/__init__.py

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

{core_framework-0.12.6 → core_framework-0.12.7}/core/auth/decorators.py

@@ -24,12 +24,33 @@ from typing import Any, TYPE_CHECKING
 from fastapi import Depends, HTTPException, Request, status
 
 from core.permissions import Permission as PermissionBase
-from core.auth.helpers import get_request_user
 
 if TYPE_CHECKING:
     pass
 
 
+def _get_user(request: Request) -> Any | None:
+    """
+    Get authenticated user from request.
+    
+    Internal helper to avoid circular imports.
+    Checks both Starlette and legacy patterns.
+    """
+    # Pattern 1: request.user (Starlette AuthenticationMiddleware)
+    user = getattr(request, "user", None)
+    if user is not None:
+        if getattr(user, "is_authenticated", False):
+            if hasattr(user, "_user"):
+                return user._user
+            return user
+    
+    # Pattern 2: request.state.user (legacy)
+    if hasattr(request, "state"):
+        return getattr(request.state, "user", None)
+    
+    return None
+
+
 # =============================================================================
 # Classes de Permissão (para uso em ViewSets)
 # =============================================================================
@@ -71,7 +92,7 @@ class HasPermission(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -136,7 +157,7 @@ class IsInGroup(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -180,7 +201,7 @@ class IsSuperuser(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -208,7 +229,7 @@ class IsStaff(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -236,7 +257,7 @@ class IsActive(PermissionBase):
         request: Request,
         view: Any = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         
         if user is None:
             return False
@@ -372,7 +393,7 @@ def login_required():
             ...
     """
     async def check(request: Request):
-        user = get_request_user(request)
+        user = _get_user(request)
         
         if user is None:
             raise HTTPException(

{core_framework-0.12.6 → core_framework-0.12.7}/core/permissions.py

@@ -15,12 +15,33 @@ from typing import Any, TYPE_CHECKING
 
 from fastapi import HTTPException, Request, status
 
-from core.auth.helpers import get_request_user
-
 if TYPE_CHECKING:
     from core.views import APIView
 
 
+def _get_user(request: Request) -> Any | None:
+    """
+    Get authenticated user from request.
+    
+    Internal helper to avoid circular imports.
+    Checks both Starlette and legacy patterns.
+    """
+    # Pattern 1: request.user (Starlette AuthenticationMiddleware)
+    user = getattr(request, "user", None)
+    if user is not None:
+        if getattr(user, "is_authenticated", False):
+            # If it's our AuthenticatedUser wrapper, return the underlying model
+            if hasattr(user, "_user"):
+                return user._user
+            return user
+    
+    # Pattern 2: request.state.user (legacy)
+    if hasattr(request, "state"):
+        return getattr(request.state, "user", None)
+    
+    return None
+
+
 class Permission(ABC):
     """
     Classe base para permissões.
@@ -34,7 +55,7 @@ class Permission(ABC):
                 request: Request,
                 view: APIView | None = None,
             ) -> bool:
-                user = get_request_user(request)
+                user = _get_user(request)
                 return user is not None and user.is_admin
     """
     
@@ -216,7 +237,7 @@ class IsAuthenticated(Permission):
         request: Request,
         view: "APIView | None" = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         return user is not None
 
 
@@ -238,7 +259,7 @@ class IsAuthenticatedOrReadOnly(Permission):
         if request.method in self.SAFE_METHODS:
             return True
         
-        user = get_request_user(request)
+        user = _get_user(request)
         return user is not None
 
 
@@ -252,7 +273,7 @@ class IsAdmin(Permission):
         request: Request,
         view: "APIView | None" = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         if user is None:
             return False
         
@@ -287,7 +308,7 @@ class IsOwner(Permission):
         if obj is None:
             return True
         
-        user = get_request_user(request)
+        user = _get_user(request)
         if user is None:
             return False
         
@@ -320,7 +341,7 @@ class HasRole(Permission):
         request: Request,
         view: "APIView | None" = None,
     ) -> bool:
-        user = get_request_user(request)
+        user = _get_user(request)
         if user is None:
             return False
         

{core_framework-0.12.6 → core_framework-0.12.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "core-framework"
-version = "0.12.6"
+version = "0.12.7"
 description = "Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema."
 requires-python = ">=3.10,<4.0"
 readme = "README.md"

core_framework-0.12.7/tests/test_auth_helpers.py

@@ -0,0 +1,206 @@
+"""
+Tests for auth helpers.
+
+These tests validate the get_request_user helper works correctly
+with both Starlette and legacy patterns.
+"""
+
+import pytest
+from unittest.mock import MagicMock, PropertyMock
+
+
+class TestGetRequestUser:
+    """Test get_request_user helper function."""
+    
+    def test_returns_none_when_no_user(self):
+        """Test returns None when no user is set."""
+        from core.auth.helpers import get_request_user
+        
+        request = MagicMock()
+        request.user = None
+        request.state = MagicMock()
+        request.state.user = None
+        
+        result = get_request_user(request)
+        assert result is None
+    
+    def test_returns_user_from_starlette_pattern(self):
+        """Test returns user from request.user (Starlette pattern)."""
+        from core.auth.helpers import get_request_user
+        
+        # Create a mock user that looks like AuthenticatedUser
+        mock_user = MagicMock()
+        mock_user.is_authenticated = True
+        mock_user._user = MagicMock()  # The underlying model
+        mock_user._user.email = "test@example.com"
+        
+        request = MagicMock()
+        request.user = mock_user
+        
+        result = get_request_user(request)
+        assert result == mock_user._user
+    
+    def test_returns_user_from_legacy_pattern(self):
+        """Test returns user from request.state.user (legacy pattern)."""
+        from core.auth.helpers import get_request_user
+        
+        mock_user = MagicMock()
+        mock_user.email = "test@example.com"
+        
+        request = MagicMock()
+        request.user = MagicMock()
+        request.user.is_authenticated = False  # Not authenticated via Starlette
+        request.state = MagicMock()
+        request.state.user = mock_user
+        
+        result = get_request_user(request)
+        assert result == mock_user
+    
+    def test_prefers_starlette_over_legacy(self):
+        """Test prefers request.user over request.state.user."""
+        from core.auth.helpers import get_request_user
+        
+        starlette_user = MagicMock()
+        starlette_user.is_authenticated = True
+        starlette_user._user = MagicMock()
+        starlette_user._user.email = "starlette@example.com"
+        
+        legacy_user = MagicMock()
+        legacy_user.email = "legacy@example.com"
+        
+        request = MagicMock()
+        request.user = starlette_user
+        request.state = MagicMock()
+        request.state.user = legacy_user
+        
+        result = get_request_user(request)
+        # Should return the Starlette user
+        assert result.email == "starlette@example.com"
+    
+    def test_handles_missing_state(self):
+        """Test handles request without state attribute."""
+        from core.auth.helpers import get_request_user
+        
+        request = MagicMock(spec=[])  # No attributes by default
+        request.user = None
+        
+        # This should not raise an error
+        result = get_request_user(request)
+        assert result is None
+
+
+class TestIsAuthenticated:
+    """Test is_authenticated helper function."""
+    
+    def test_returns_false_when_no_user(self):
+        """Test returns False when no user."""
+        from core.auth.helpers import is_authenticated
+        
+        request = MagicMock()
+        request.user = None
+        request.state = MagicMock()
+        request.state.user = None
+        
+        assert is_authenticated(request) is False
+    
+    def test_returns_true_for_starlette_user(self):
+        """Test returns True for Starlette authenticated user."""
+        from core.auth.helpers import is_authenticated
+        
+        mock_user = MagicMock()
+        mock_user.is_authenticated = True
+        
+        request = MagicMock()
+        request.user = mock_user
+        
+        assert is_authenticated(request) is True
+    
+    def test_returns_true_for_legacy_user(self):
+        """Test returns True for legacy user."""
+        from core.auth.helpers import is_authenticated
+        
+        mock_user = MagicMock()
+        
+        request = MagicMock()
+        request.user = MagicMock()
+        request.user.is_authenticated = False
+        request.state = MagicMock()
+        request.state.user = mock_user
+        
+        assert is_authenticated(request) is True
+
+
+class TestSetRequestUser:
+    """Test set_request_user helper function."""
+    
+    def test_sets_user_on_state(self):
+        """Test sets user on request.state."""
+        from core.auth.helpers import set_request_user
+        
+        mock_user = MagicMock()
+        request = MagicMock()
+        request.state = MagicMock()
+        
+        set_request_user(request, mock_user)
+        
+        assert request.state.user == mock_user
+    
+    def test_clears_user_when_none(self):
+        """Test clears user when None is passed."""
+        from core.auth.helpers import set_request_user
+        
+        request = MagicMock()
+        request.state = MagicMock()
+        request.state.user = MagicMock()  # Previous user
+        
+        set_request_user(request, None)
+        
+        assert request.state.user is None
+
+
+class TestAuthenticatedUserWrapper:
+    """Test AuthenticatedUser wrapper class."""
+    
+    def test_is_authenticated_property(self):
+        """Test is_authenticated returns True."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.is_authenticated is True
+    
+    def test_proxies_attributes(self):
+        """Test proxies attribute access to underlying model."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        mock_model.email = "test@example.com"
+        mock_model.id = 123
+        
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.email == "test@example.com"
+        assert wrapper.id == 123
+    
+    def test_display_name(self):
+        """Test display_name returns email."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        mock_model.email = "test@example.com"
+        
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.display_name == "test@example.com"
+    
+    def test_identity(self):
+        """Test identity returns string id."""
+        from core.auth.middleware import AuthenticatedUser
+        
+        mock_model = MagicMock()
+        mock_model.id = 123
+        
+        wrapper = AuthenticatedUser(mock_model)
+        
+        assert wrapper.identity == "123"

core_framework-0.12.7/tests/test_imports.py

@@ -0,0 +1,263 @@
+"""
+Tests for module imports.
+
+These tests ensure there are no circular imports or missing dependencies.
+Run these BEFORE committing any changes!
+"""
+
+import pytest
+
+
+class TestCoreImports:
+    """Test that core modules can be imported without errors."""
+    
+    def test_import_core(self):
+        """Test importing the main core module."""
+        import core
+        assert hasattr(core, "__version__")
+    
+    def test_import_core_models(self):
+        """Test importing core.models."""
+        from core.models import Model, Field
+        assert Model is not None
+        assert Field is not None
+    
+    def test_import_core_views(self):
+        """Test importing core.views."""
+        from core.views import ViewSet, ModelViewSet, action
+        assert ViewSet is not None
+        assert ModelViewSet is not None
+        assert action is not None
+    
+    def test_import_core_permissions(self):
+        """Test importing core.permissions."""
+        from core.permissions import (
+            Permission,
+            AllowAny,
+            DenyAll,
+            IsAuthenticated,
+            IsAuthenticatedOrReadOnly,
+            IsAdmin,
+            IsOwner,
+            HasRole,
+            check_permissions,
+        )
+        assert Permission is not None
+        assert IsAuthenticated is not None
+    
+    def test_import_core_exceptions(self):
+        """Test importing core.exceptions."""
+        from core.exceptions import (
+            CoreException,
+            ValidationException,
+            DatabaseException,
+            AuthException,
+            InvalidToken,
+            TokenExpired,
+            PermissionDenied,
+            NotFound,
+            Unauthorized,
+        )
+        assert CoreException is not None
+        assert InvalidToken is not None
+
+
+class TestAuthImports:
+    """Test that auth modules can be imported without circular import errors."""
+    
+    def test_import_auth_module(self):
+        """Test importing the main auth module."""
+        from core.auth import (
+            configure_auth,
+            get_auth_config,
+            AuthBackend,
+            TokenBackend,
+        )
+        assert configure_auth is not None
+    
+    def test_import_auth_models(self):
+        """Test importing auth models."""
+        from core.auth.models import (
+            AbstractUser,
+            AbstractUUIDUser,
+            PermissionsMixin,
+            Group,
+            Permission,
+        )
+        assert AbstractUser is not None
+        assert AbstractUUIDUser is not None
+    
+    def test_import_auth_tokens(self):
+        """Test importing auth tokens."""
+        from core.auth.tokens import (
+            create_access_token,
+            create_refresh_token,
+            decode_token,
+            verify_token,
+            JWTBackend,
+        )
+        assert create_access_token is not None
+        assert JWTBackend is not None
+    
+    def test_import_auth_middleware(self):
+        """Test importing auth middleware."""
+        from core.auth.middleware import (
+            AuthenticationMiddleware,
+            OptionalAuthenticationMiddleware,
+            JWTAuthBackend,
+            AuthenticatedUser,
+        )
+        assert AuthenticationMiddleware is not None
+        assert JWTAuthBackend is not None
+    
+    def test_import_auth_decorators(self):
+        """Test importing auth decorators."""
+        from core.auth.decorators import (
+            HasPermission,
+            IsInGroup,
+            IsSuperuser,
+            IsStaff,
+            IsActive,
+            require_permission,
+            require_group,
+            login_required,
+        )
+        assert HasPermission is not None
+        assert login_required is not None
+    
+    def test_import_auth_helpers(self):
+        """Test importing auth helpers."""
+        from core.auth.helpers import (
+            get_request_user,
+            is_authenticated,
+            set_request_user,
+        )
+        assert get_request_user is not None
+        assert is_authenticated is not None
+    
+    def test_import_auth_schemas(self):
+        """Test importing auth schemas."""
+        from core.auth.schemas import (
+            BaseRegisterInput,
+            BaseLoginInput,
+            TokenResponse,
+            BaseUserOutput,
+        )
+        assert BaseRegisterInput is not None
+        assert TokenResponse is not None
+    
+    def test_import_auth_views(self):
+        """Test importing auth views."""
+        from core.auth.views import AuthViewSet
+        assert AuthViewSet is not None
+
+
+class TestMiddlewareImports:
+    """Test that middleware modules can be imported."""
+    
+    def test_import_middleware(self):
+        """Test importing core.middleware."""
+        from core.middleware import (
+            BaseMiddleware,
+            configure_middleware,
+            apply_middlewares,
+            TimingMiddleware,
+            RequestIDMiddleware,
+            LoggingMiddleware,
+        )
+        assert BaseMiddleware is not None
+        assert configure_middleware is not None
+
+
+class TestDependenciesImports:
+    """Test that dependencies can be imported."""
+    
+    def test_import_dependencies(self):
+        """Test importing core.dependencies."""
+        from core.dependencies import (
+            get_db,
+            get_current_user,
+            get_optional_user,
+            DatabaseSession,
+            CurrentUser,
+        )
+        assert get_db is not None
+        assert get_current_user is not None
+
+
+class TestTenancyImports:
+    """Test that tenancy modules can be imported."""
+    
+    def test_import_tenancy(self):
+        """Test importing core.tenancy."""
+        from core.tenancy import (
+            TenantMixin,
+            set_tenant,
+            get_tenant,
+            clear_tenant,
+        )
+        assert TenantMixin is not None
+        assert set_tenant is not None
+
+
+class TestMigrationsImports:
+    """Test that migrations modules can be imported."""
+    
+    def test_import_migrations(self):
+        """Test importing core.migrations."""
+        from core.migrations import (
+            MigrationEngine,
+            Operation,
+            CreateTable,
+            DropTable,
+        )
+        assert MigrationEngine is not None
+        assert CreateTable is not None
+
+
+class TestImportOrder:
+    """Test that imports work in various orders (to catch hidden circular deps)."""
+    
+    def test_permissions_before_auth(self):
+        """Test importing permissions before auth."""
+        from core.permissions import IsAuthenticated
+        from core.auth import AuthViewSet
+        assert IsAuthenticated is not None
+        assert AuthViewSet is not None
+    
+    def test_auth_before_permissions(self):
+        """Test importing auth before permissions."""
+        from core.auth import AuthViewSet
+        from core.permissions import IsAuthenticated
+        assert AuthViewSet is not None
+        assert IsAuthenticated is not None
+    
+    def test_views_before_auth(self):
+        """Test importing views before auth."""
+        from core.views import ViewSet
+        from core.auth import AuthViewSet
+        assert ViewSet is not None
+        assert AuthViewSet is not None
+    
+    def test_all_together(self):
+        """Test importing everything at once."""
+        from core import (
+            Model,
+            ViewSet,
+            ModelViewSet,
+        )
+        from core.auth import (
+            AbstractUser,
+            AuthViewSet,
+            configure_auth,
+        )
+        from core.permissions import (
+            IsAuthenticated,
+            AllowAny,
+        )
+        from core.middleware import (
+            BaseMiddleware,
+        )
+        assert Model is not None
+        assert AuthViewSet is not None
+        assert IsAuthenticated is not None