hyperpocket 0.0.3__py3-none-any.whl → 0.1.9__py3-none-any.whl

hyperpocket/auth/tests/test_slack_oauth2_handler.py

@@ -1,147 +0,0 @@
-import uuid
-from datetime import timezone, datetime
-from unittest.async_case import IsolatedAsyncioTestCase
-from unittest.mock import patch
-from urllib.parse import urlparse, parse_qs
-
-import httpx
-
-from hyperpocket.auth import SlackOAuth2AuthContext
-from hyperpocket.auth.slack.oauth2_handler import SlackOAuth2AuthHandler
-from hyperpocket.auth.slack.oauth2_schema import SlackOAuth2Request, SlackOAuth2Response
-from hyperpocket.config import config
-from hyperpocket.config.auth import SlackAuthConfig
-from hyperpocket.futures import FutureStore
-
-
-class TestSlackOAuth2AuthHandler(IsolatedAsyncioTestCase):
-
-    async def asyncSetUp(self):
-        config.auth.slack = SlackAuthConfig(
-            client_id="test-client-id",
-            client_secret="test-client-secret",
-        )
-
-        self.handler = SlackOAuth2AuthHandler()
-        self.auth_req = SlackOAuth2Request(
-            auth_scopes=["channels:history", "im:history", "mpim:history", "groups:history", "reactions:read"],
-            client_id="test-client-id",
-            client_secret="test-client-secret",
-        )
-
-    async def test_make_auth_url(self):
-        future_uid = str(uuid.uuid4())
-
-        auth_url = self.handler._make_auth_url(
-            req=self.auth_req,
-            redirect_uri="http://test-redirect-uri.com",
-            state=future_uid
-        )
-        parsed = urlparse(auth_url)
-        query_params = parse_qs(parsed.query)
-        base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
-
-        # then
-        self.assertEqual(base_url, SlackOAuth2AuthHandler._SLACK_OAUTH_URL)
-        self.assertEqual(query_params["state"][0], future_uid)
-        self.assertEqual(query_params["redirect_uri"][0], "http://test-redirect-uri.com")
-        self.assertEqual(query_params["client_id"][0], "test-client-id")
-        self.assertEqual(query_params["user_scope"][0],
-                         "channels:history,im:history,mpim:history,groups:history,reactions:read")
-
-    async def test_prepare(self):
-        future_uid = str(uuid.uuid4())
-
-        # when
-        prepare: str = self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-prepare-thread-id",
-            profile="test-prepare-profile",
-            future_uid=future_uid,
-        )
-        auth_url = prepare.removeprefix("User needs to authenticate using the following URL:").strip()
-        future_data = FutureStore.get_future( uid=future_uid)
-
-        # then
-        self.assertTrue(auth_url.startswith(SlackOAuth2AuthHandler._SLACK_OAUTH_URL))
-        self.assertIsNotNone(future_data)
-        self.assertEqual(future_data.data["thread_id"], "test-prepare-thread-id")
-        self.assertEqual(future_data.data["profile"], "test-prepare-profile")
-        self.assertFalse(future_data.future.done())
-
-    async def test_authenticate(self):
-        # given
-        future_uid = str(uuid.uuid4())
-        mock_response = httpx.Response(
-            status_code=200,
-            json={
-                "ok": True,
-                "authed_user": {
-                    "id": "test-user",
-                    "access_token": "test-token"
-                }
-
-            }
-        )
-
-        # when
-        self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-thread-id",
-            profile="test-profile",
-            future_uid=future_uid
-        )
-        future_data = FutureStore.get_future( uid=future_uid)
-        future_data.future.set_result("test-code")
-
-        with patch("httpx.AsyncClient.post", return_value=mock_response):
-            response: SlackOAuth2AuthContext = await self.handler.authenticate(
-                auth_req=self.auth_req,
-                future_uid=future_uid
-            )
-
-        self.assertIsInstance(response, SlackOAuth2AuthContext)
-        self.assertEqual(response.access_token, "test-token")
-
-    async def test_refresh(self):
-        # given
-        # https://api.slack.com/authentication/rotation
-        mock_response = httpx.Response(
-            status_code=200,
-            json={
-                "ok": True,
-                "access_token": "new-access-token",
-                "refresh_token": "new-refresh-token",
-                "expires_in": 3600,
-            }
-        )
-
-        response = SlackOAuth2Response(
-            **{
-                "ok": True,
-                "authed_user": {
-                    "id": "test",
-                    "access_token": "access-token",
-                    "refresh_token": "refresh-token",
-                    "expires_in": 3600,
-                }
-            }
-        )
-        context = SlackOAuth2AuthContext.from_slack_oauth2_response(response)
-
-        # when
-        with patch("httpx.AsyncClient.post", return_value=mock_response):
-            new_context: SlackOAuth2AuthContext = await self.handler.refresh(
-                auth_req=self.auth_req,
-                context=context
-            )
-
-        time_diff = (new_context.expires_at - datetime.now(tz=timezone.utc))
-
-        # then
-        self.assertIsInstance(new_context, SlackOAuth2AuthContext)
-        self.assertEqual(context.access_token, "access-token")
-        self.assertEqual(context.refresh_token, "refresh-token")
-        self.assertEqual(new_context.access_token, "new-access-token")
-        self.assertEqual(new_context.refresh_token, "new-refresh-token")
-        self.assertTrue(time_diff.total_seconds() > 3500)

hyperpocket/auth/tests/test_slack_token_handler.py

@@ -1,66 +0,0 @@
-from unittest.async_case import IsolatedAsyncioTestCase
-from urllib.parse import urlparse, parse_qs
-
-from hyperpocket.auth import SlackTokenAuthContext
-from hyperpocket.auth.slack.token_handler import SlackTokenAuthHandler
-from hyperpocket.auth.slack.token_schema import SlackTokenRequest
-from hyperpocket.futures import FutureStore
-
-
-class TestSlackTokenAuthHandler(IsolatedAsyncioTestCase):
-
-    async def asyncSetUp(self):
-        self.handler: SlackTokenAuthHandler = SlackTokenAuthHandler()
-        self.auth_req = SlackTokenRequest()
-
-    async def test_make_auth_url(self):
-        auth_url = self.handler._make_auth_url(
-            req=self.auth_req,
-            redirect_uri="http://test-redirect-uri.com",
-            state="test-future-id"
-        )
-        parsed = urlparse(auth_url)
-        query_params = parse_qs(parsed.query)
-        base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
-
-        # then
-        self.assertEqual(base_url, self.handler._TOKEN_URL)
-        self.assertEqual(query_params["state"][0], "test-future-id")
-        self.assertEqual(query_params["redirect_uri"][0], "http://test-redirect-uri.com")
-
-    async def test_prepare(self):
-        # when
-        prepare: str = self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-prepare-thread-id",
-            profile="test-prepare-profile",
-            future_uid="test-prepare-future-uid",
-        )
-        auth_url = prepare.removeprefix("User needs to authenticate using the following URL:").strip()
-        future_data = FutureStore.get_future( uid="test-prepare-future-uid")
-
-        # then
-        self.assertTrue(auth_url.startswith(self.handler._TOKEN_URL))
-        self.assertIsNotNone(future_data)
-        self.assertEqual(future_data.data["thread_id"], "test-prepare-thread-id")
-        self.assertEqual(future_data.data["profile"], "test-prepare-profile")
-        self.assertFalse(future_data.future.done())
-
-    async def test_authenticate(self):
-        self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-thread-id",
-            profile="test-profile",
-            future_uid="test-future-uid"
-        )
-        future_data = FutureStore.get_future( uid="test-future-uid")
-        future_data.future.set_result("test-token")
-
-        response: SlackTokenAuthContext = await self.handler.authenticate(
-            auth_req=self.auth_req,
-            future_uid="test-future-uid"
-        )
-
-        self.assertIsInstance(response, SlackTokenAuthContext)
-        self.assertEqual(response.access_token, "test-token")
-        self.assertIsNone(response.expires_at)

hyperpocket/external/__init__.py

@@ -1,7 +0,0 @@
-from hyperpocket.external.github_client import github_instance
-
-github = github_instance()
-
-__all__ = [
-    "github",
-]

hyperpocket/external/github_client.py

@@ -1,19 +0,0 @@
-from github import Auth, Github, GithubIntegration
-
-from hyperpocket.config import config
-
-_github = None
-
-
-def github_instance() -> Github:
-    global _github
-    if _github is None:
-        if config.git.github.github_token:
-            _github = Github(auth=Auth.Token(config.git.github.github_token))
-        elif config.git.github.app_id:
-            auth = Auth.AppAuth(config.git.github.app_id, config.git.github.app_private_key)
-            gi = GithubIntegration(auth=auth)
-            _github = gi.get_github_for_installation(config.git.github.app_installation_id)
-        else:
-            _github = Github()
-    return _github

hyperpocket/session/README.KR.md

@@ -1,62 +0,0 @@
-# Session Storage
-
-유저의 authentication(auth) session을 저장하기 위한 storage
-
-## Current supported session storage
-
-- [x] InMemory
-- [x] Redis
-- [ ] Postgres
-- [ ] Mysql
-- [ ] Mongodb
-
-## SessionKey
-
-세션 키는 유저의 인증 정보를 식별하기 위한 유니크 키이다.
-
-일반적으로 세션 키는 다음 세 가지 요소로 식별될 수 있다.
-
-- auth provider
-- profile
-- thread_id
-
-하나의 auth provider에서는 하나의 session만 가질 수 있다.
-
-- 예를 들어 slack token으로 이미 인증한 사용자가 oauth로 인증하려 하면 이전 세션은 사라지게 된다.
-
-- profile은 pocket에서 지원하는 개념으로 하나의 thread_id에 여러 profile이 존재할 수 있다.
-
-- profile을 이용해 한 사용자는 여러 persona를 갖고 작업을 수행하도록 할 수 있다.
-    - e.g., A group의 슬랙 메세지를 읽어 B group으로 요약해서 전달
-
-## BaseSessionValue
-
-```python
-class BaseSessionValue(BaseModel):
-    auth_provider_name: str
-    auth_context: Optional[AuthContext] = None
-    scoped: bool
-    auth_scopes: Optional[Set[str]] = None
-    auth_resolve_uid: Optional[str] = None
-```
-
-기본적으로 Session에는 다음 정보들을 갖고 있다.
-
-- auth_provider_name : 현재 세션을 인증한 auth provider name
-- auth_context : 실제 세션 내용이 들어있는 auth context
-- scoped : 현재 세션이 scoped session인지 여부
-- auth_scopes : 현재 세션의 auth scopes. scoped session의 경우에만 존재
-- auth_resolve_uid : 유저가 auth 인증을 완료했는지를 비동기적으로 확인하기 위한 uid
-
-## SessionStorageInterface
-
-TBU
-
-## How To Implement
-
-1. `pocket/config/session.py` 내에 새로운 SessionType Enum 추가
-2. `pocket/config/session.py` 내에 새로운 SessionConfig 추가
-3. SessionStorageInterface 구현
-    - session storage가 초기화될 때 위에서 정의한 SessionConfig를 입력으로 받아야 한다.
-
-

hyperpocket/session/tests/test_in_memory.py

@@ -1,145 +0,0 @@
-import unittest
-
-from hyperpocket.auth import AuthProvider, SlackTokenAuthContext
-from hyperpocket.config.session import SessionConfigInMemory
-from hyperpocket.session.in_memory import InMemorySessionStorage, InMemorySessionValue
-
-
-class TestInMemorySessionStorage(unittest.TestCase):
-    storage: InMemorySessionStorage
-    context: SlackTokenAuthContext
-
-    def setUp(self):
-        self.storage = InMemorySessionStorage(SessionConfigInMemory())
-        self.auth_context = SlackTokenAuthContext(
-            access_token="test",
-            description="test-description",
-            expires_at=None,
-            detail=None,
-        )
-
-    def tearDown(self):
-        del self.storage
-        del self.auth_context
-
-    def test_make_session_key(self):
-        key = self.storage._make_session_key(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile"
-        )
-
-        self.assertEqual(key, "SLACK__default_thread_id__default_profile")
-
-    def test_make_session(self):
-        session = self.storage._make_session(
-            auth_provider_name=AuthProvider.SLACK.name,
-            auth_scopes=["scope1", "scope2"],
-            auth_context=self.auth_context,
-            auth_resolve_uid="test-resolve-uid",
-            is_auth_scope_universal=True
-        )
-
-        # then
-        self.assertIsInstance(session, InMemorySessionValue)
-        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
-        self.assertEqual(session.auth_context.access_token, "test")
-        self.assertEqual(session.auth_context.description, "test-description")
-
-    def test_set(self):
-        session = self.storage.set(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-            auth_scopes=["scope1", "scope2"],
-            auth_resolve_uid="test-resolve-uid",
-            auth_context=self.auth_context,
-            is_auth_scope_universal=True
-        )
-
-        self.assertIsInstance(session, InMemorySessionValue)
-        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
-        self.assertEqual(session.auth_context.access_token, self.auth_context.access_token)
-        self.assertEqual(session.auth_context.description, self.auth_context.description)
-
-    def test_get_existing_data(self):
-        # given
-        self.storage.set(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-            auth_scopes=["scope1", "scope2"],
-            auth_resolve_uid="test-resolve-uid",
-            auth_context=self.auth_context,
-            is_auth_scope_universal=True
-        )
-
-        # when
-        session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertIsInstance(session, InMemorySessionValue)
-        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
-        self.assertEqual(session.auth_context.access_token, "test")
-        self.assertEqual(session.auth_context.description, "test-description")
-
-    def test_get_not_existing_data(self):
-        # when
-        session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertIsNone(session)
-
-    def test_delete_existing_data(self):
-        # given
-        self.storage.set(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-            auth_scopes=["scope1", "scope2"],
-            auth_resolve_uid="test-resolve-uid",
-            auth_context=self.auth_context,
-            is_auth_scope_universal=True
-        )
-
-        # when
-        before_session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        deleted = self.storage.delete(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        after_session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertTrue(deleted)
-        self.assertIsNotNone(before_session)
-        self.assertIsNone(after_session)
-
-    def test_delete_not_existing_data(self):
-        deleted = self.storage.delete(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertFalse(deleted)

hyperpocket/session/tests/test_redis.py

@@ -1,151 +0,0 @@
-import unittest
-
-from hyperpocket.auth import AuthProvider, SlackTokenAuthContext
-from hyperpocket.config.session import SessionConfigRedis
-from hyperpocket.session.in_memory import InMemorySessionValue
-from hyperpocket.session.redis import RedisSessionStorage, RedisSessionValue
-
-
-class TestRedisSessionStorage(unittest.TestCase):
-    storage: RedisSessionStorage
-    context: SlackTokenAuthContext
-
-    def setUp(self):
-        self.storage = RedisSessionStorage(SessionConfigRedis(
-            host="localhost",
-            port=6379,
-            db="9"
-        ))
-        self.storage.client.flushdb()
-
-        self.auth_context = SlackTokenAuthContext(
-            access_token="test",
-            description="test-description",
-            expires_at=None,
-            detail=None,
-        )
-
-    def tearDown(self):
-        self.storage.client.flushdb()
-
-    def test_make_session_key(self):
-        key = self.storage._make_session_key(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile"
-        )
-
-        self.assertEqual(key, "SLACK__default_thread_id__default_profile")
-
-    def test_make_session(self):
-        session = self.storage._make_session(
-            auth_provider_name=AuthProvider.SLACK.name,
-            auth_scopes=["scope1", "scope2"],
-            auth_context=self.auth_context,
-            auth_resolve_uid="test-resolve-uid",
-            is_auth_scope_universal=True
-        )
-
-        # then
-        self.assertIsInstance(session, RedisSessionValue)
-        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
-        self.assertEqual(session.auth_context.access_token, "test")
-        self.assertEqual(session.auth_context.description, "test-description")
-
-    def test_set(self):
-        session = self.storage.set(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-            auth_scopes=["scope1", "scope2"],
-            auth_resolve_uid="test-resolve-uid",
-            auth_context=self.auth_context,
-            is_auth_scope_universal=True
-        )
-
-        self.assertIsInstance(session, InMemorySessionValue)
-        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
-        self.assertEqual(session.auth_context.access_token, self.auth_context.access_token)
-        self.assertEqual(session.auth_context.description, self.auth_context.description)
-
-    def test_get_existing_data(self):
-        # given
-        self.storage.set(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-            auth_scopes=["scope1", "scope2"],
-            auth_resolve_uid="test-resolve-uid",
-            auth_context=self.auth_context,
-            is_auth_scope_universal=True
-        )
-
-        # when
-        session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertIsInstance(session, InMemorySessionValue)
-        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
-        self.assertEqual(session.auth_context.access_token, "test")
-        self.assertEqual(session.auth_context.description, "test-description")
-
-    def test_get_not_existing_data(self):
-        # when
-        session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertIsNone(session)
-
-    def test_delete_existing_data(self):
-        # given
-        self.storage.set(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-            auth_scopes=["scope1", "scope2"],
-            auth_resolve_uid="test-resolve-uid",
-            auth_context=self.auth_context,
-            is_auth_scope_universal=True
-        )
-
-        # when
-        before_session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        deleted = self.storage.delete(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        after_session = self.storage.get(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertTrue(deleted)
-        self.assertIsNotNone(before_session)
-        self.assertIsNone(after_session)
-
-    def test_delete_not_existing_data(self):
-        deleted = self.storage.delete(
-            auth_provider=AuthProvider.SLACK,
-            thread_id="default_thread_id",
-            profile="default_profile",
-        )
-
-        # then
-        self.assertFalse(deleted)