usso 0.28.0__tar.gz → 0.28.1__tar.gz

{usso-0.28.0/src/usso.egg-info → usso-0.28.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usso
-Version: 0.28.0
+Version: 0.28.1
 Summary: A plug-and-play client for integrating universal single sign-on (SSO) with Python frameworks, enabling secure and seamless authentication across microservices.
 Author-email: Mahdi Kiani <mahdikiany@gmail.com>
 Maintainer-email: Mahdi Kiani <mahdikiany@gmail.com>

{usso-0.28.0 → usso-0.28.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "usso"
-version = "0.28.0"
+version = "0.28.1"
 description = "A plug-and-play client for integrating universal single sign-on (SSO) with Python frameworks, enabling secure and seamless authentication across microservices."
 readme = "README.md"
 requires-python = ">=3.9"

{usso-0.28.0 → usso-0.28.1}/src/usso/auth/client.py

@@ -65,10 +65,12 @@ class UssoAuth:
             except usso_jwt.exceptions.JWTError as e:
                 exp = e
 
-        if raise_exception:
-            if exp:
-                _handle_exception("unauthorized", message=str(exp), **kwargs)
-            _handle_exception("unauthorized", **kwargs)
+        _handle_exception(
+            "Unauthorized",
+            message=str(exp) if exp else None,
+            raise_exception=raise_exception,
+            **kwargs,
+        )
 
     def user_data_from_api_key(self, api_key: str) -> UserData:
         """Get user data from an API key.

usso-0.28.1/src/usso/integrations/fastapi/__init__.py

@@ -0,0 +1,8 @@
+from .dependency import USSOAuthentication
+from .handler import EXCEPTION_HANDLERS, usso_exception_handler
+
+__all__ = [
+    "USSOAuthentication",
+    "EXCEPTION_HANDLERS",
+    "usso_exception_handler",
+]

{usso-0.28.0 → usso-0.28.1}/src/usso/integrations/fastapi/dependency.py

@@ -1,13 +1,10 @@
 import logging
 
-from starlette.status import HTTP_401_UNAUTHORIZED
-
 from fastapi import Request, WebSocket
-from fastapi.responses import JSONResponse
 
 from ...auth import UssoAuth
 from ...auth.config import AuthConfig, AvailableJwtConfigs
-from ...exceptions import USSOException
+from ...exceptions import _handle_exception
 from ...models.user import UserData
 from ...utils.method_utils import instance_method
 
@@ -26,6 +23,9 @@ class USSOAuthentication(UssoAuth):
         super().__init__(jwt_config=jwt_config)
         self.raise_exception = raise_exception
 
+    def __call__(self, request: Request) -> UserData:
+        return self.usso_access_security(request)
+
     @instance_method
     def get_request_jwt(self, request: Request | WebSocket) -> str | None:
         for jwt_config in self.jwt_configs:
@@ -42,7 +42,7 @@ class USSOAuthentication(UssoAuth):
                 return token
         return None
 
-    @instance_method
+    # @instance_method
     def usso_access_security(self, request: Request) -> UserData | None:
         """Return the user associated with a token value."""
         api_key = self.get_request_api_key(request)
@@ -54,15 +54,14 @@ class USSOAuthentication(UssoAuth):
             return self.user_data_from_token(
                 token, raise_exception=self.raise_exception
             )
-        if self.raise_exception:
-            raise USSOException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                error="unauthorized",
-                message="No token provided",
-            )
-        return None
 
-    @instance_method
+        _handle_exception(
+            "Unauthorized",
+            message="No token provided",
+            raise_exception=self.raise_exception,
+        )
+
+    # @instance_method
     def jwt_access_security_ws(self, websocket: WebSocket) -> UserData | None:
         """Return the user associated with a token value."""
         api_key = self.get_request_api_key(websocket)
@@ -74,22 +73,8 @@ class USSOAuthentication(UssoAuth):
             return self.user_data_from_token(
                 token, raise_exception=self.raise_exception
             )
-        if self.raise_exception:
-            raise USSOException(
-                status_code=HTTP_401_UNAUTHORIZED,
-                error="unauthorized",
-                message="No token provided",
-            )
-        return None
-
-
-async def usso_exception_handler(request: Request, exc: USSOException):
-    return JSONResponse(
-        status_code=exc.status_code,
-        content={"message": exc.message, "error": exc.error},
-    )
-
-
-EXCEPTION_HANDLERS = {
-    USSOException: usso_exception_handler,
-}
+        _handle_exception(
+            "Unauthorized",
+            message="No token provided",
+            raise_exception=self.raise_exception,
+        )

usso-0.28.1/src/usso/integrations/fastapi/handler.py

@@ -0,0 +1,16 @@
+from fastapi import Request
+from fastapi.responses import JSONResponse
+
+from ...exceptions import USSOException
+
+
+async def usso_exception_handler(request: Request, exc: USSOException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"message": exc.message, "error": exc.error},
+    )
+
+
+EXCEPTION_HANDLERS = {
+    USSOException: usso_exception_handler,
+}

{usso-0.28.0 → usso-0.28.1/src/usso.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usso
-Version: 0.28.0
+Version: 0.28.1
 Summary: A plug-and-play client for integrating universal single sign-on (SSO) with Python frameworks, enabling secure and seamless authentication across microservices.
 Author-email: Mahdi Kiani <mahdikiany@gmail.com>
 Maintainer-email: Mahdi Kiani <mahdikiany@gmail.com>

{usso-0.28.0 → usso-0.28.1}/src/usso.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/usso/integrations/django/__init__.py
 src/usso/integrations/django/middleware.py
 src/usso/integrations/fastapi/__init__.py
 src/usso/integrations/fastapi/dependency.py
+src/usso/integrations/fastapi/handler.py
 src/usso/models/user.py
 src/usso/session/__init__.py
 src/usso/session/async_session.py

usso-0.28.1/tests/test_fastapi.py

@@ -0,0 +1,102 @@
+import json
+import os
+from collections.abc import AsyncGenerator
+
+import httpx
+import pytest
+import pytest_asyncio
+from fastapi import Depends, WebSocket
+from starlette.testclient import TestClient
+from usso_jwt.algorithms import AbstractKey
+
+from src.usso import UserData
+from src.usso.exceptions import USSOException
+from src.usso.integrations.fastapi import (
+    USSOAuthentication,
+    usso_exception_handler,
+)
+
+
+@pytest.fixture(scope="session")
+def app(test_key: AbstractKey):
+    import fastapi
+
+    os.environ["JWT_CONFIG"] = json.dumps({
+        "type": "EDDSA",
+        "key": test_key.public_pem().decode(),
+        "jwt_header": {"type": "Authorization"},
+    })
+
+    app = fastapi.FastAPI()
+
+    app.add_exception_handler(USSOException, usso_exception_handler)
+
+    usso = USSOAuthentication()
+
+    @app.get("/user")
+    async def get_user(
+        user: UserData = Depends(usso.usso_access_security),  # noqa: B008
+    ):
+        return user.model_dump()
+
+    @app.websocket("/ws")
+    async def websocket_endpoint(
+        websocket: WebSocket,
+        user: UserData = Depends(usso.jwt_access_security_ws),
+    ):
+        await websocket.accept()
+        await websocket.send_json({"msg": user.model_dump()})
+        # await websocket.send_json({"msg": "Hello WebSocket"})
+        await websocket.close()
+
+    return app
+
+
+@pytest_asyncio.fixture(scope="session")
+async def client(app) -> AsyncGenerator[httpx.AsyncClient]:
+    """Fixture to provide an AsyncClient for FastAPI app."""
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        base_url="http://test.uln.me",
+    ) as ac:
+        yield ac
+
+
+@pytest.mark.asyncio
+async def test_get_user_no_token(client: httpx.AsyncClient):
+    response = await client.get("/user")
+    print(response.json())
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_get_user_with_invalid_token(client: httpx.AsyncClient):
+    response = await client.get(
+        "/user",
+        headers={"Authorization": "Bearer test"},
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_get_user_with_token(
+    client: httpx.AsyncClient,
+    test_valid_token: str,
+    test_valid_payload: dict,
+):
+    response = await client.get(
+        "/user",
+        headers={"Authorization": f"Bearer {test_valid_token}"},
+    )
+    assert response.status_code == 200
+    assert response.json().get("claims") == test_valid_payload
+
+
+def test_websocket(app, test_valid_token: str, test_valid_payload: dict):
+    client = TestClient(app)
+    with client.websocket_connect(
+        "/ws", headers={"Authorization": f"Bearer {test_valid_token}"}
+    ) as websocket:
+        data = websocket.receive_json()
+        assert data.get("msg").get("claims") == test_valid_payload

usso-0.28.0/src/usso/integrations/fastapi/__init__.py

@@ -1,3 +0,0 @@
-from .dependency import USSOAuthentication
-
-__all__ = ["USSOAuthentication"]

usso-0.28.0/tests/test_fastapi.py

@@ -1,79 +0,0 @@
-from collections.abc import AsyncGenerator
-
-import httpx
-import pytest
-import pytest_asyncio
-from fastapi import Depends
-from usso_jwt.algorithms import AbstractKey
-
-from src.usso import AuthConfig, UserData
-from src.usso.exceptions import USSOException
-from src.usso.integrations.fastapi import USSOAuthentication
-
-
-@pytest.fixture(scope="session")
-def app(test_key: AbstractKey):
-    import fastapi
-
-    app = fastapi.FastAPI()
-    config = AuthConfig(
-        key=test_key.public_pem(),
-        jwt_header={"type": "Authorization"},
-    )
-    usso = USSOAuthentication(jwt_config=config)
-
-    async def get_current_user(request: fastapi.Request) -> UserData:
-        return usso.usso_access_security(request)
-
-    @app.get("/user")
-    async def get_user(
-        user: UserData = Depends(get_current_user),  # noqa: B008
-    ):
-        print(user)
-        return user.model_dump()
-
-    return app
-
-
-@pytest_asyncio.fixture(scope="session")
-async def client(app) -> AsyncGenerator[httpx.AsyncClient]:
-    """Fixture to provide an AsyncClient for FastAPI app."""
-
-    async with httpx.AsyncClient(
-        transport=httpx.ASGITransport(app=app),
-        base_url="http://test.uln.me",
-    ) as ac:
-        yield ac
-
-
-@pytest.mark.asyncio
-async def test_get_user_no_token(client: httpx.AsyncClient):
-    with pytest.raises(USSOException):
-        response = await client.get("/user")
-        print(response.json())
-        assert response.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_get_user_with_invalid_token(client: httpx.AsyncClient):
-    with pytest.raises(USSOException):
-        response = await client.get(
-            "/user",
-            headers={"Authorization": "Bearer test"},
-        )
-        assert response.status_code == 401
-
-
-@pytest.mark.asyncio
-async def test_get_user_with_token(
-    client: httpx.AsyncClient,
-    test_valid_token: str,
-    test_valid_payload: dict,
-):
-    response = await client.get(
-        "/user",
-        headers={"Authorization": f"Bearer {test_valid_token}"},
-    )
-    assert response.status_code == 200
-    print(response.json(), test_valid_payload)
-    assert response.json().get("claims") == test_valid_payload