usso 0.18.0__tar.gz → 0.20.0__tar.gz

{usso-0.18.0/src/usso.egg-info → usso-0.20.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "usso"
-version = "0.18.0"
+version = "0.20.0"
 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.8"

usso-0.20.0/src/usso/__init__.py

@@ -0,0 +1,3 @@
+from .core import UserData, Usso
+
+__all__ = ["UserData", "Usso"]

usso-0.20.0/src/usso/api.py

@@ -0,0 +1,177 @@
+import requests
+from singleton import Singleton
+
+from usso.core import UserData, Usso
+
+
+class UssoAPI(metaclass=Singleton):
+    def __init__(
+        self,
+        url: str = "https://api.usso.io",
+        api_key: str = None,
+        refresh_token: str = None,
+    ):
+        if url and not url.startswith("http"):
+            url = f"https://{url}"
+        self.url = url
+        assert (
+            api_key or refresh_token
+        ), "Either api_key or refresh_token must be provided"
+        self.api_key = api_key
+        self.refresh_token = refresh_token
+        self.access_token = None
+
+    def _refresh(self):
+        if not self.refresh_token:
+            return
+
+        url = f"{self.url}/auth/refresh"
+
+        if self.refresh_token:
+            headers = {
+                "Authorization": f"Bearer {self.refresh_token}",
+                "content-type": "application/json",
+            }
+
+        resp = requests.post(url, headers=headers)
+        self.access_token = resp.json().get("access_token")
+
+    def _access_valid(self) -> bool:
+        if not self.access_token:
+            return False
+
+        user_data = Usso(
+            jwks_url=f"{self.url}/website/jwks.json?"
+        ).user_data_from_token(self.access_token)
+        if user_data:
+            return True
+        return False
+
+    def _request(
+        self,
+        method="get",
+        endpoint: str = "",
+        data: dict = None,
+        **kwargs,
+    ) -> dict:
+        url = f"{self.url}/{endpoint}"
+        headers = {"content-type": "application/json"}
+        if self.api_key:
+            headers["x-api-key"] = self.api_key
+        elif self.refresh_token:
+            if not self.access_token:
+                self._refresh()
+            headers["Authorization"] = f"Bearer {self.access_token}"
+
+        resp = requests.request(
+            method,
+            url,
+            headers=headers,
+            json=data,
+        )
+        if kwargs.get("raise", True):
+            resp.raise_for_status()
+        return resp.json()
+
+    def get_users(self, **kwargs) -> list[UserData]:
+        users_dict = self._request(endpoint="website/users", **kwargs)
+
+        return [
+            UserData(user_id=user.get("uid"), **user) for user in users_dict
+        ]
+
+    def get_user(self, user_id: str, **kwargs) -> UserData:
+        return UserData(
+            **self._request(
+                endpoint=f"website/users/{user_id}",
+                **kwargs,
+            )
+        )
+
+    def get_user_credentials(self, user_id: str, **kwargs) -> UserData:
+        return UserData(
+            **self._request(
+                endpoint=f"website/users/{user_id}/credentials",
+                **kwargs,
+            )
+        )
+
+    def get_user_by_credentials(self, credentials: dict, **kwargs) -> UserData:
+        return UserData(
+            **self._request(
+                endpoint="website/users/credentials",
+                data=credentials,
+                **kwargs,
+            )
+        )
+
+    def create_user(self, user_data: dict, **kwargs) -> UserData:
+        return UserData(
+            **self._request(
+                method="post",
+                endpoint="website/users",
+                data=user_data,
+                **kwargs,
+            )
+        )
+
+    def create_user_credentials(
+        self, user_id: str, credentials: dict, **kwargs
+    ) -> UserData:
+        return UserData(
+            **self._request(
+                method="post",
+                endpoint=f"website/users/{user_id}/credentials",
+                data=credentials,
+                **kwargs,
+            )
+        )
+
+    def create_user_by_credentials(
+        self,
+        user_data: dict | None = None,
+        credentials: dict | None = None,
+        **kwargs,
+    ) -> UserData:
+
+        if credentials:
+            user_data["authenticators"] = [credentials]
+        return UserData(
+            **self._request(
+                method="post",
+                endpoint="website/users",
+                data=user_data,
+                **kwargs,
+            )
+        )
+
+    def get_user_payload(self, user_id: str, **kwargs) -> dict:
+        return self._request(
+            endpoint=f"website/users/{user_id}/payload", **kwargs
+        )
+
+    def update_user_payload(
+        self,
+        user_id: str,
+        payload: dict,
+        **kwargs,
+    ) -> dict:
+        return self._request(
+            method="patch",
+            endpoint=f"website/users/{user_id}/payload",
+            data=payload,
+            **kwargs,
+        )
+
+    def set_user_payload(
+        self,
+        user_id: str,
+        payload: dict,
+        **kwargs,
+    ) -> dict:
+        return self._request(
+            method="put",
+            endpoint=f"website/users/{user_id}/payload",
+            data=payload,
+            **kwargs,
+        )

{usso-0.18.0 → usso-0.20.0/src/usso.egg-info}/PKG-INFO

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

@@ -15,4 +15,6 @@ src/usso.egg-info/requires.txt
 src/usso.egg-info/top_level.txt
 src/usso/fastapi/__init__.py
 src/usso/fastapi/integration.py
+tests/test_api.py
+tests/test_core.py
 tests/test_simple.py

usso-0.20.0/tests/test_api.py

@@ -0,0 +1,67 @@
+import os
+import unittest
+
+from usso.api import UssoAPI
+
+
+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, dict)
+            self.assertIn("user_id", user)
+            self.assertIn("username", user)
+            self.assertIn("email", user)
+        return users
+
+    def test_get_user(self):
+        users = self.test_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, dict)
+        self.assertIn("user_id", user)
+        self.assertIn("username", user)
+        self.assertIn("email", user)
+        return user
+
+    def test_get_user_credentials(self):
+        users = self.test_get_users()
+        if len(users) == 0:
+            self.skipTest("No users found")
+        user = users[0]
+        usso_api = self.get_usso()
+        credentials = usso_api.get_user_credentials(user["user_id"])
+        self.assertIsInstance(credentials, list)
+        for credential in credentials:
+            self.assertIsInstance(credential, dict)
+            self.assertIn("credential_id", credential)
+            self.assertIn("type", credential)
+            self.assertIn("created_at", credential)
+        return credentials
+
+    def test_get_user_by_credentials(self):
+        credentials = self.test_get_user_credentials()
+        if len(credentials) == 0:
+            self.skipTest("No credentials found")
+        credential = credentials[0]
+        usso_api = self.get_usso()
+        user = usso_api.get_user_by_credentials(credential)
+        self.assertIsInstance(user, dict)
+        self.assertIn("user_id", user)
+        self.assertIn("username", user)
+        self.assertIn("email", user)
+        return user
+
+if __name__ == "__main__":
+    unittest.main()

usso-0.20.0/tests/test_core.py

@@ -0,0 +1,76 @@
+import unittest
+import uuid
+
+from usso.core import user_data_from_token
+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):
+        # Generate a valid token for testing
+        valid_token = generate_valid_token()
+
+        # Call the user_data_from_token function with the valid token
+        user_data = 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):
+        # Generate an expired token for testing
+        expired_token = generate_expired_token()
+
+        # Call the user_data_from_token function with the expired token
+        user_data = 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:
+            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):
+        # Generate an invalid token for testing
+        invalid_token = generate_invalid_token()
+
+        # Call the user_data_from_token function with the invalid token
+        user_data = 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:
+            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.18.0 → usso-0.20.0}/tests/test_simple.py

@@ -6,8 +6,11 @@ import unittest
 
 
 class TestSimple(unittest.TestCase):
-    def test_add_one(self):
-        self.assertEqual(5 + 1, 6)
+    def test_import(self):
+        import usso
+
+        usso.Usso()
+        usso.UserData()
 
 
 if __name__ == "__main__":

usso-0.18.0/src/usso/__init__.py

@@ -1,3 +0,0 @@
-from .core import UserData, user_data_from_token
-
-__all__ = ["UserData", "user_data_from_token"]

usso-0.18.0/src/usso/api.py

@@ -1,108 +0,0 @@
-import requests
-from singleton import Singleton
-
-from usso.core import Usso
-
-
-class UssoAPI(metaclass=Singleton):
-    def __init__(
-        self,
-        url: str = "https://api.usso.io",
-        api_key: str = None,
-        refresh_token: str = None,
-    ):
-        self.url = url
-        assert (
-            api_key or refresh_token
-        ), "Either api_key or refresh_token must be provided"
-        self.api_key = api_key
-        self.refresh_token = refresh_token
-        self.access_token = None
-
-    def refresh(self):
-        if not self.refresh_token:
-            return
-
-        url = f"{self.url}/auth/refresh"
-
-        if self.refresh_token:
-            headers = {"Authorization": f"Bearer {self.refresh_token}"}
-
-        resp = requests.post(url, headers=headers)
-        self.access_token = resp.json().get("access_token")
-
-    def _access_valid(self):
-        if not self.access_token:
-            return False
-
-        user_data = Usso(
-            jwks_url=f"{self.url}/website/jwks.json?"
-        ).user_data_from_token(self.access_token)
-        if user_data:
-            return True
-        return False
-
-    def _request(self, method="get", endpoint: str = "", data: dict = None):
-        url = f"{self.url}/{endpoint}"
-        headers = {}
-        if self.api_key:
-            headers["x-api-key"] = self.api_key
-        elif self.refresh_token:
-            if not self.access_token:
-                self.refresh()
-            headers["Authorization"] = f"Bearer {self.access_token}"
-
-        resp = requests.request(method, url, headers=headers, json=data)
-        return resp.json()
-
-    def get_users(self):
-        return self._request(endpoint="website/users/")
-
-    def get_user(self, user_id: str):
-        return self._request(endpoint=f"website/users/{user_id}/")
-
-    def get_user_credentials(self, user_id: str):
-        return self._request(endpoint=f"website/users/{user_id}/credentials/")
-
-    def get_user_by_credentials(self, credentials: dict):
-        return self._request(
-            endpoint="website/users/credentials/", data=credentials
-        )
-
-    def create_user(self, user_data: dict):
-        return self._request(
-            method="post", endpoint="website/users/", data=user_data
-        )
-
-    def create_user_credentials(self, user_id: str, credentials: dict):
-        return self._request(
-            method="post",
-            endpoint=f"website/users/{user_id}/credentials/",
-            data=credentials,
-        )
-
-    def create_user_by_credentials(
-        self, user_data: dict, credentials: dict | None = None
-    ):
-        if credentials:
-            user_data["authenticators"] = [credentials]
-        return self._request(
-            method="post", endpoint="website/users/", data=user_data
-        )
-
-    def get_user_payload(self, user_id: str):
-        return self._request(endpoint=f"website/users/{user_id}/payload/")
-
-    def update_user_payload(self, user_id: str, payload: dict):
-        return self._request(
-            method="patch",
-            endpoint=f"website/users/{user_id}/payload/",
-            data=payload,
-        )
-
-    def set_user_payload(self, user_id: str, payload: dict):
-        return self._request(
-            method="put",
-            endpoint=f"website/users/{user_id}/payload/",
-            data=payload,
-        )

{usso-0.18.0 → usso-0.20.0}/src/usso/core.py

@@ -1,12 +1,12 @@
-import os
 import logging
+import os
 import uuid
 from functools import lru_cache
 from typing import Optional, Tuple
-from singleton import Singleton
 
 import jwt
 from pydantic import BaseModel
+from singleton import Singleton
 
 from . import b64tools
 from .exceptions import USSOException