usso 0.27.11__tar.gz → 0.27.13__tar.gz

{usso-0.27.11/src/usso.egg-info → usso-0.27.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: usso
-Version: 0.27.11
+Version: 0.27.13
 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.27.11 → usso-0.27.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "usso"
-version = "0.27.11"
+version = "0.27.13"
 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.27.13/src/usso/core.py

@@ -0,0 +1,156 @@
+import json
+import logging
+import os
+from datetime import datetime, timedelta
+from urllib.parse import urlparse
+
+import cachetools.func
+import httpx
+import jwt
+
+from .exceptions import USSOException
+from .schemas import JWTConfig, UserData
+
+logger = logging.getLogger("usso")
+
+
+def get_authorization_scheme_param(
+    authorization_header_value: str | None,
+) -> tuple[str, str]:
+    if not authorization_header_value:
+        return "", ""
+    scheme, _, param = authorization_header_value.partition(" ")
+    return scheme, param
+
+
+def decode_token(key, token: str, algorithms=["RS256"], **kwargs) -> dict:
+    """Decode a JWT token."""
+    try:
+        decoded = jwt.decode(token, key, algorithms=algorithms)
+        decoded.update({"data": decoded, "token": token})
+        return UserData(**decoded)
+    except jwt.ExpiredSignatureError:
+        _handle_exception("expired_signature", **kwargs)
+    except jwt.InvalidSignatureError:
+        _handle_exception("invalid_signature", **kwargs)
+    except jwt.InvalidAlgorithmError:
+        _handle_exception("invalid_algorithm", **kwargs)
+    except jwt.InvalidIssuedAtError:
+        _handle_exception("invalid_issued_at", **kwargs)
+    except jwt.InvalidTokenError:
+        _handle_exception("invalid_token", **kwargs)
+    except jwt.InvalidKeyError:
+        _handle_exception("invalid_key", **kwargs)
+    except Exception as e:
+        _handle_exception("error", message=str(e), **kwargs)
+
+
+def _handle_exception(error_type: str, **kwargs):
+    """Handle JWT-related exceptions."""
+    if kwargs.get("raise_exception", True):
+        raise USSOException(
+            status_code=401, error=error_type, message=kwargs.get("message")
+        )
+    logger.error(kwargs.get("message") or error_type)
+
+
+def is_expired(token: str, **kwargs) -> bool:
+    now = datetime.now()
+    decoded_token: dict = jwt.decode(token, options={"verify_signature": False})
+    exp = decoded_token.get("exp", (now + timedelta(days=1)).timestamp())
+    exp = datetime.fromtimestamp(exp)
+    return exp < now
+
+
+@cachetools.func.ttl_cache(maxsize=128, ttl=10 * 60)
+def get_jwk_keys(jwk_url: str) -> jwt.PyJWKClient:
+    return jwt.PyJWKClient(jwk_url, headers={"User-Agent": "usso-python"})
+
+
+def decode_token_with_jwk(jwk_url: str, token: str, **kwargs) -> UserData | None:
+    """Return the user associated with a token value."""
+    try:
+        jwk_client = get_jwk_keys(jwk_url)
+        signing_key = jwk_client.get_signing_key_from_jwt(token)
+        return decode_token(signing_key.key, token, **kwargs)
+    except Exception as e:
+        _handle_exception("error", message=str(e), **kwargs)
+
+
+@cachetools.func.ttl_cache(maxsize=128, ttl=10 * 60)
+def fetch_api_key_data(jwk_url: str, api_key: str):
+    parsed = urlparse(jwk_url)
+    url = f"{parsed.scheme}://{parsed.netloc}/api_key/verify"
+    response = httpx.post(url, json={"api_key": api_key})
+    response.raise_for_status()
+    return UserData(**response.json())
+
+
+class Usso:
+    def __init__(
+        self,
+        *,
+        jwt_config: (
+            str | dict | JWTConfig | list[str] | list[dict] | list[JWTConfig] | None
+        ) = None,
+        jwk_url: str | None = None,
+        secret: str | None = None,
+    ):
+        self.jwt_configs = self._initialize_configs(jwt_config, jwk_url, secret)
+
+    def _initialize_configs(
+        self,
+        jwt_config: (
+            str | dict | JWTConfig | list[str] | list[dict] | list[JWTConfig] | None
+        ) = None,
+        jwk_url: str | None = None,
+        secret: str | None = None,
+    ):
+        """Initialize JWT configurations."""
+        if jwt_config is None:
+            jwt_config = os.getenv("USSO_JWT_CONFIG")
+
+        if jwt_config is None:
+            jwk_url = jwk_url or os.getenv("USSO_JWK_URL") or os.getenv("USSO_JWKS_URL")
+            secret = secret or os.getenv("USSO_SECRET")
+            if jwk_url:
+                return [JWTConfig(jwk_url=jwk_url)]
+            if secret:
+                return [JWTConfig(secret=secret)]
+            raise ValueError(
+                "Provide jwt_config, jwk_url, or secret, or set the appropriate environment variables."
+            )
+
+        if isinstance(jwt_config, (str, dict, JWTConfig)):
+            return [self._parse_config(jwt_config)]
+        if isinstance(jwt_config, list):
+            return [self._parse_config(config) for config in jwt_config]
+        raise ValueError("Invalid jwt_config format")
+
+    def _parse_config(self, config):
+        """Parse a single JWT configuration."""
+        if isinstance(config, str):
+            config = json.loads(config)
+        if isinstance(config, dict):
+            return JWTConfig(**config)
+        return config
+
+    def user_data_from_token(self, token: str, **kwargs) -> UserData | None:
+        """Return the user associated with a token value."""
+        exp = None
+        for jwk_config in self.jwt_configs:
+            try:
+                user_data = jwk_config.decode(token)
+                if user_data.token_type.lower() != kwargs.get("token_type", "access"):
+                    _handle_exception("invalid_token_type", **kwargs)
+                return user_data
+            except USSOException as e:
+                exp = e
+
+        if kwargs.get("raise_exception", True):
+            if exp:
+                _handle_exception(exp.error, message=str(exp), **kwargs)
+            _handle_exception("unauthorized", **kwargs)
+
+    def user_data_from_api_key(self, api_key: str):
+        return fetch_api_key_data(self.jwt_configs[0].jwk_url, api_key)

{usso-0.27.11 → usso-0.27.13}/src/usso/exceptions.py

@@ -1,8 +1,9 @@
 error_messages = {
-    "invalid_signature": "Invalid signature",
-    "invalid_token": "Invalid token",
-    "expired_signature": "Expired signature",
+    "invalid_signature": "Unauthorized. The JWT signature is invalid.",
+    "invalid_token": "Unauthorized. The JWT is invalid or not provided.",
+    "expired_signature": "Unauthorized. The JWT is expired.",
     "unauthorized": "Unauthorized",
+    "invalid_token_type": "Unauthorized. Token type must be 'access'",
 }
 
 
@@ -14,4 +15,3 @@ class USSOException(Exception):
         if message is None:
             self.message = error_messages[error]
         super().__init__(message)
-

usso-0.27.13/src/usso/schemas.py

@@ -0,0 +1,67 @@
+import uuid
+
+import cachetools.func
+from pydantic import BaseModel, model_validator
+
+from . import b64tools
+
+
+class UserData(BaseModel):
+    user_id: str
+    workspace_id: str | None = None
+    workspace_ids: list[str] = []
+    token_type: str = "access"
+
+    email: str | None = None
+    phone: str | None = None
+    username: str | None = None
+
+    authentication_method: str | None = None
+    is_active: bool = False
+
+    jti: str | None = None
+    data: dict | None = None
+
+    token: str | None = None
+
+    @property
+    def uid(self) -> uuid.UUID:
+        user_id = self.user_id
+
+        if user_id.startswith("u_"):
+            user_id = user_id[2:]
+        if 22 <= len(user_id) <= 24:
+            user_id = b64tools.b64_decode_uuid(user_id)
+
+        return uuid.UUID(user_id)
+
+    @property
+    def b64id(self) -> uuid.UUID:
+        return b64tools.b64_encode_uuid_strip(self.uid)
+
+
+class JWTConfig(BaseModel):
+    """Configuration for JWT processing."""
+
+    jwk_url: str | None = None
+    secret: str | None = None
+    algorithm: str = "RS256"
+    header: dict[str, str] = {"type": "Cookie", "name": "usso_access_token"}
+
+    def __hash__(self):
+        return hash(self.model_dump_json())
+
+    @model_validator(mode="before")
+    def validate_config(cls, data: dict):
+        if not data.get("jwk_url") and not data.get("secret"):
+            raise ValueError("Either jwk_url or secret must be provided")
+        return data
+
+    @cachetools.func.ttl_cache(maxsize=128, ttl=600)
+    def decode(self, token: str):
+        """Decode a token using the configured method."""
+        from .core import decode_token, decode_token_with_jwk
+
+        if self.jwk_url:
+            return decode_token_with_jwk(self.jwk_url, token)
+        return decode_token(self.secret, token, algorithms=[self.algorithm])

{usso-0.27.11 → usso-0.27.13}/src/usso/session/async_session.py

@@ -1,5 +1,7 @@
 import os
+
 import httpx
+
 from ..core import is_expired
 from .base_session import BaseUssoSession
 
@@ -17,18 +19,16 @@ class AsyncUssoSession(httpx.AsyncClient, BaseUssoSession):
         client: "AsyncUssoSession" | None = None,
     ):
         httpx.AsyncClient.__init__(self)
-        if client:
-            self.copy_attributes_from(client)
-        else:
-            BaseUssoSession.__init__(
-                self,
-                usso_base_url=usso_base_url,
-                api_key=api_key,
-                usso_refresh_url=usso_refresh_url,
-                refresh_token=refresh_token,
-                usso_api_key=usso_api_key,
-                user_id=user_id,
-            )
+        BaseUssoSession.__init__(
+            self,
+            usso_base_url=usso_base_url,
+            api_key=api_key,
+            usso_refresh_url=usso_refresh_url,
+            refresh_token=refresh_token,
+            usso_api_key=usso_api_key,
+            user_id=user_id,
+            client=client,
+        )
         self._refresh_sync()
 
     def _prepare_refresh_request(self) -> tuple[dict, dict]:

{usso-0.27.11 → usso-0.27.13}/src/usso/session/base_session.py

@@ -1,5 +1,6 @@
 import os
 from urllib.parse import urlparse
+
 from usso.core import is_expired
 
 
@@ -13,7 +14,12 @@ class BaseUssoSession:
         refresh_token: str | None = os.getenv("USSO_REFRESH_TOKEN"),
         usso_api_key: str | None = os.getenv("USSO_ADMIN_API_KEY"),
         user_id: str | None = None,
+        client: "BaseUssoSession" | None = None,
     ):
+        if client:
+            self.copy_attributes_from(client)
+            return
+
         assert (
             usso_base_url or usso_refresh_url
         ), "usso_base_url or usso_refresh_url is required"

{usso-0.27.11 → usso-0.27.13}/src/usso/session/session.py

@@ -1,12 +1,13 @@
 import os
 
 import httpx
+
 from usso.core import is_expired
 
 from .base_session import BaseUssoSession
 
 
-class UssoSession(BaseUssoSession, httpx.Client):
+class UssoSession(httpx.Client, BaseUssoSession):
 
     def __init__(
         self,
@@ -21,18 +22,16 @@ class UssoSession(BaseUssoSession, httpx.Client):
     ):
         httpx.Client.__init__(self)
 
-        if client:
-            self.copy_attributes_from(client)
-        else:
-            BaseUssoSession.__init__(
-                self,
-                usso_base_url=usso_base_url,
-                api_key=api_key,
-                usso_refresh_url=usso_refresh_url,
-                refresh_token=refresh_token,
-                usso_api_key=usso_api_key,
-                user_id=user_id,
-            )
+        BaseUssoSession.__init__(
+            self,
+            usso_base_url=usso_base_url,
+            api_key=api_key,
+            usso_refresh_url=usso_refresh_url,
+            refresh_token=refresh_token,
+            usso_api_key=usso_api_key,
+            user_id=user_id,
+            client=client,
+        )
         self._refresh()
 
     def _refresh_api(self):

{usso-0.27.11 → usso-0.27.13/src/usso.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: usso
-Version: 0.27.11
+Version: 0.27.13
 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.27.11 → usso-0.27.13}/src/usso.egg-info/SOURCES.txt

@@ -22,7 +22,4 @@ src/usso/fastapi/integration.py
 src/usso/session/__init__.py
 src/usso/session/async_session.py
 src/usso/session/base_session.py
-src/usso/session/session.py
-tests/test_api.py
-tests/test_core.py
-tests/test_simple.py
+src/usso/session/session.py

usso-0.27.11/src/usso/core.py

@@ -1,233 +0,0 @@
-import json
-import logging
-import os
-from datetime import datetime, timedelta
-from urllib.parse import urlparse
-
-import cachetools.func
-import jwt
-import requests
-from cachetools import TTLCache, cached
-from pydantic import BaseModel, model_validator
-
-from .exceptions import USSOException
-from .schemas import UserData
-
-logger = logging.getLogger("usso")
-
-
-def get_authorization_scheme_param(
-    authorization_header_value: str | None,
-) -> tuple[str, str]:
-    if not authorization_header_value:
-        return "", ""
-    scheme, _, param = authorization_header_value.partition(" ")
-    return scheme, param
-
-
-def decode_token(key, token: str, algorithms=["RS256"], **kwargs) -> dict:
-    try:
-        decoded = jwt.decode(token, key, algorithms=algorithms)
-        decoded["data"] = decoded
-        decoded["token"] = token
-        return UserData(**decoded)
-    except jwt.exceptions.ExpiredSignatureError:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="expired_signature")
-    except jwt.exceptions.InvalidSignatureError:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="invalid_signature")
-    except jwt.exceptions.InvalidAlgorithmError:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="invalid_algorithm")
-    except jwt.exceptions.InvalidIssuedAtError:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="invalid_issued_at")
-    except jwt.exceptions.InvalidTokenError:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="invalid_token")
-    except jwt.exceptions.InvalidKeyError:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="invalid_key")
-    except USSOException as e:
-        if kwargs.get("raise_exception", True):
-            raise e
-    except Exception as e:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(status_code=401, error="error", message=str(e))
-        logger.error(e)
-
-
-def is_expired(token: str, **kwargs) -> bool:
-    now = datetime.now()
-    decoded_token: dict = jwt.decode(token, options={"verify_signature": False})
-    exp = decoded_token.get("exp", (now + timedelta(days=1)).timestamp())
-    exp = datetime.fromtimestamp(exp)
-    return exp < now
-
-
-@cached(TTLCache(maxsize=128, ttl=10 * 60))
-def get_jwk_keys(jwk_url: str) -> jwt.PyJWKClient:
-    return jwt.PyJWKClient(jwk_url, headers={"User-Agent": "usso-python"})
-
-
-def decode_token_jwk(jwk_url: str, token: str, **kwargs) -> UserData | None:
-    """Return the user associated with a token value."""
-    try:
-        jwk_client = get_jwk_keys(jwk_url)
-        signing_key = jwk_client.get_signing_key_from_jwt(token)
-        return decode_token(signing_key.key, token, **kwargs)
-    except USSOException as e:
-        if kwargs.get("raise_exception", True):
-            raise e
-        logger.error(e)
-    except Exception as e:
-        if kwargs.get("raise_exception", True):
-            raise USSOException(
-                status_code=401,
-                error="error",
-                message=str(e),
-            )
-        logger.error(e)
-
-
-@cached(TTLCache(maxsize=128, ttl=10 * 60))
-def get_api_key_data(jwk_url: str, api_key: str):
-    parsed = urlparse(jwk_url)
-    url = f"{parsed.scheme}://{parsed.netloc}/api_key/verify"
-    response = requests.post(url, json={"api_key": api_key})
-    response.raise_for_status()
-    return UserData(**response.json())
-
-
-class JWTConfig(BaseModel):
-    jwk_url: str | None = None
-    secret: str | None = None
-    type: str = "RS256"
-    header: dict[str, str] = {"type": "Cookie", "name": "usso_access_token"}
-
-    def __hash__(self):
-        return hash(self.model_dump_json())
-
-    @model_validator(mode="before")
-    def validate_secret(cls, data: dict):
-        if not data.get("jwk_url") and not data.get("secret"):
-            raise ValueError("Either jwk_url or secret must be provided")
-        return data
-
-    @classmethod
-    @cachetools.func.ttl_cache(maxsize=128, ttl=10 * 60)
-    def get_jwk_keys(cls, jwk_url):
-        return get_jwk_keys(jwk_url)
-
-    @cachetools.func.ttl_cache(maxsize=128, ttl=10 * 60)
-    def decode(self, token: str):
-        if self.jwk_url:
-            return decode_token_jwk(self.jwk_url, token)
-        return decode_token(self.secret, token, algorithms=[self.type])
-
-
-class Usso:
-
-    def __init__(
-        self,
-        *,
-        jwt_config: (
-            str | dict | JWTConfig | list[str] | list[dict] | list[JWTConfig] | None
-        ) = None,
-        jwk_url: str | None = None,
-        secret: str | None = None,
-    ):
-        if jwt_config is None:
-            jwt_config = os.getenv("USSO_JWT_CONFIG")
-
-        if jwt_config is None:
-            if not jwk_url:
-                jwk_url = os.getenv("USSO_JWK_URL") or os.getenv("USSO_JWKS_URL")
-            if jwk_url:
-                self.jwt_configs = [JWTConfig(jwk_url=jwk_url)]
-                return
-
-            if not secret:
-                secret = os.getenv("USSO_SECRET")
-            if secret:
-                self.jwt_configs = [JWTConfig(secret=secret)]
-                return
-
-            raise ValueError(
-                "\n".join(
-                    [
-                        "jwt_config or jwk_url or secret must be provided",
-                        "or set the environment variable USSO_JWT_CONFIG or USSO_JWK_URL or USSO_SECRET",
-                    ]
-                )
-            )
-
-        def _get_config(jwt_config):
-            if isinstance(jwt_config, str):
-                jwt_config = json.loads(jwt_config)
-            if isinstance(jwt_config, dict):
-                jwt_config = JWTConfig(**jwt_config)
-            return jwt_config
-
-        if isinstance(jwt_config, str | dict | JWTConfig):
-            jwt_config = [_get_config(jwt_config)]
-        elif isinstance(jwt_config, list):
-            jwt_config = [_get_config(j) for j in jwt_config]
-
-        # self.jwk_url = jwt_config
-        self.jwt_configs = jwt_config
-
-    def user_data_from_token(self, token: str, **kwargs) -> UserData | None:
-        """Return the user associated with a token value."""
-        exp = None
-        for jwk_config in self.jwt_configs:
-            try:
-                user_data = jwk_config.decode(token)
-                if user_data.token_type.lower() != kwargs.get("token_type", "access"):
-                    raise USSOException(
-                        status_code=401,
-                        error="invalid_token_type",
-                        message="Token type must be 'access'",
-                    )
-
-                return user_data
-
-            except USSOException as e:
-                exp = e
-
-        if kwargs.get("raise_exception", True):
-            if exp:
-                raise exp
-            raise USSOException(
-                status_code=401,
-                error="unauthorized",
-            )
-
-    def user_data_api_key(self, api_key: str, **kwargs) -> UserData | None:
-        """get user data from auth server by api_key."""
-        for jwk_config in self.jwt_configs:
-            try:
-                user_data = jwk_config.decode(api_key)
-                if user_data.token_type.lower() != kwargs.get("token_type", "access"):
-                    raise USSOException(
-                        status_code=401,
-                        error="invalid_token_type",
-                        message="Token type must be 'access'",
-                    )
-
-                return user_data
-
-            except USSOException as e:
-                exp = e
-
-        if kwargs.get("raise_exception", True):
-            if exp:
-                raise exp
-            raise USSOException(
-                status_code=401,
-                error="unauthorized",
-            )
-
-    def user_data_from_api_key(self, api_key: str):
-        return get_api_key_data(self.jwt_configs[0].jwk_url, api_key)

usso-0.27.11/src/usso/schemas.py

@@ -1,39 +0,0 @@
-import uuid
-
-from pydantic import BaseModel
-
-from . import b64tools
-
-
-class UserData(BaseModel):
-    user_id: str
-    workspace_id: str | None = None
-    workspace_ids: list[str] = []
-    token_type: str = "access"
-
-    email: str | None = None
-    phone: str | None = None
-    username: str | None = None
-
-    authentication_method: str | None = None
-    is_active: bool = False
-
-    jti: str | None = None
-    data: dict | None = None
-
-    token: str | None = None
-
-    @property
-    def uid(self) -> uuid.UUID:
-        user_id = self.user_id
-
-        if user_id.startswith("u_"):
-            user_id = user_id[2:]
-        if 22 <= len(user_id) <= 24:
-            user_id = b64tools.b64_decode_uuid(user_id)
-
-        return uuid.UUID(user_id)
-
-    @property
-    def b64id(self) -> uuid.UUID:
-        return b64tools.b64_encode_uuid_strip(self.uid)

usso-0.27.11/tests/test_api.py

@@ -1,61 +0,0 @@
-import os
-import unittest
-
-from usso.api import UssoAPI
-from usso.core import UserData
-
-
-class TestAPI(unittest.TestCase):
-    def get_usso(self):
-        return UssoAPI(
-            url="https://sso.usso.io",
-            api_key=os.getenv("USSO_API_KEY"),
-        )
-
-    def test_get_users(self):
-        usso_api = self.get_usso()
-        users = usso_api.get_users()
-        self.assertIsInstance(users, list)
-        for user in users:
-            self.assertIsInstance(user, UserData)
-
-    def test_get_user(self):
-        usso_api = self.get_usso()
-        users = usso_api.get_users()
-        if len(users) == 0:
-            self.skipTest("No users found")
-        user = users[0]
-        usso_api = self.get_usso()
-        user = usso_api.get_user(user.user_id)
-        self.assertIsInstance(user, UserData)
-
-    def test_get_user_by_credentials(self):
-        usso_api = self.get_usso()
-        users = usso_api._request(endpoint="website/users")
-        if len(users) == 0:
-            self.skipTest("No users found")
-        for user in users:
-            for auth in user["authenticators"]:
-                cred = {
-                    "auth_method": auth["auth_method"],
-                    "representor": auth["representor"],
-                }
-                user = usso_api.get_user_by_credentials(cred)
-                self.assertIsInstance(user, UserData)
-
-    def test_create_user_by_credentials(self):
-        import requests
-
-        usso_api = self.get_usso()
-        telegram_id = os.getenv("TELEGRAM_ID")
-        cred = {"auth_method": "telegram", "representor": telegram_id}
-        try:
-            usso_api.create_user_by_credentials(credentials=cred)
-        except requests.HTTPError as e:
-            if e.response.status_code == 400:
-                if e.response.json().get("error") == "already_exists":
-                    self.skipTest("Credential already exists")
-
-
-if __name__ == "__main__":
-    unittest.main()

usso-0.27.11/tests/test_core.py

@@ -1,81 +0,0 @@
-import unittest
-import uuid
-
-from usso.core import Usso
-from usso.exceptions import USSOException
-
-
-def generate_expired_token():
-    # Your code to generate an expired token goes here
-    pass
-
-
-# Generate an invalid token for testing
-def generate_invalid_token():
-    # Your code to generate an invalid token goes here
-    pass
-
-
-# Generate a valid token for testing
-def generate_valid_token():
-    # Your code to generate a valid token goes here
-    pass
-
-
-class TestCore(unittest.TestCase):
-    def test_user_data_from_token_valid_token(self):
-        return
-        # Generate a valid token for testing
-        valid_token = generate_valid_token()
-
-        # Call the user_data_from_token function with the valid token
-        user_data = Usso().user_data_from_token(valid_token)
-
-        # Assert that the user_data is not None
-        self.assertIsNotNone(user_data)
-
-        # Assert that the user_data has the expected attributes
-        self.assertEqual(user_data.uid, uuid.UUID(""))
-        self.assertEqual(user_data.token, valid_token)
-        # Add more assertions for other attributes
-        # Generate an expired token for testing
-
-    def test_user_data_from_token_expired_token(self):
-        return
-
-        # Generate an expired token for testing
-        expired_token = generate_expired_token()
-
-        # Call the user_data_from_token function with the expired token
-        user_data = Usso().user_data_from_token(expired_token)
-
-        # Assert that the user_data is None
-        self.assertIsNone(user_data)
-
-        # Assert that the USSOException is raised with the expected error
-        with self.assertRaises(USSOException) as context:
-            Usso().user_data_from_token(expired_token, raise_exception=True)
-        self.assertEqual(context.exception.error, "expired_signature")
-
-    def test_user_data_from_token_invalid_token(self):
-        return
-
-        # Generate an invalid token for testing
-        invalid_token = generate_invalid_token()
-
-        # Call the user_data_from_token function with the invalid token
-        user_data = Usso().user_data_from_token(invalid_token)
-
-        # Assert that the user_data is None
-        self.assertIsNone(user_data)
-
-        # Assert that the USSOException is raised with the expected error
-        with self.assertRaises(USSOException) as context:
-            Usso().user_data_from_token(invalid_token, raise_exception=True)
-        self.assertEqual(context.exception.error, "invalid_signature")
-
-    # Add more test cases for other scenarios
-
-
-if __name__ == "__main__":
-    unittest.main()

usso-0.27.11/tests/test_simple.py

@@ -1,17 +0,0 @@
-# the inclusion of the tests module is not meant to offer best practices for
-# testing in general, but rather to support the `find_packages` example in
-# setup.py that excludes installing the "tests" package
-
-import unittest
-
-
-class TestSimple(unittest.TestCase):
-    def test_import(self):
-        import usso
-
-        usso.Usso()
-        usso.UserData(user_id="123")
-
-
-if __name__ == "__main__":
-    unittest.main()