hyperpocket 0.0.1__py3-none-any.whl

hyperpocket/session/tests/test_redis.py

@@ -0,0 +1,151 @@
+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)

hyperpocket/tests/test_pocket.py

@@ -0,0 +1,118 @@
+from pathlib import Path
+from unittest.async_case import IsolatedAsyncioTestCase
+
+from pydantic import BaseModel
+
+from hyperpocket import Pocket
+from hyperpocket.config import config
+from hyperpocket.tool import from_local
+
+
+class TestPocket(IsolatedAsyncioTestCase):
+
+    async def asyncSetUp(self):
+        self.profile = "test-profile"
+        self.thread_id = "test_thread_id"
+
+        config.public_server_port = "https"
+        config.public_hostname = "localhost"
+        config.public_server_port = 8001
+        config.internal_server_port = 8000
+        config.enable_local_callback_proxy = True
+
+        import hyperpocket
+        path = Path(hyperpocket.__file__).parent.parent.parent.parent / "examples/tool/simple-echo-tool"
+        self.pocket = Pocket(
+            tools=[
+                from_local(str(path)),
+                self.add,
+                self.add_pydantic_args
+            ],
+        )
+
+    async def test_function_tool(self):
+        # given
+        tool_name = "add"
+
+        # when
+        result = await self.pocket.ainvoke(
+            tool_name=tool_name,
+            body={
+                "a": 1,
+                "b": 3
+            },
+            thread_id=self.thread_id,
+            profile=self.profile,
+        )
+
+        # then
+        self.assertEqual(result, "4")
+
+    async def test_pydantic_arg_function_tool(self):
+        # given
+        tool_name = "add_pydantic_args"
+
+        # when
+        result = await self.pocket.ainvoke(
+            tool_name=tool_name,
+            body={
+                "a": {
+                    "first": 1
+                },
+                "b": {
+                    "second": 3
+                }
+            },
+            thread_id=self.thread_id,
+            profile=self.profile,
+        )
+
+        # then
+        self.assertEqual(result, "4")
+
+    async def test_wasm_tool(self):
+        # given
+        tool_name = "simple_echo_text"
+
+        # when
+        result = await self.pocket.ainvoke(
+            tool_name=tool_name,
+            body={
+                "text": "test"
+            },
+            thread_id=self.thread_id,
+            profile=self.profile,
+        )
+
+        # then
+        self.assertTrue(result.startswith("echo message : test"))
+
+    @staticmethod
+    def add(a: int, b: int) -> int:
+        """
+        Add two numbers
+
+        Args:
+            a(int): first number
+            b(int): second number
+
+        """
+
+        return a + b
+
+    class FirstNumber(BaseModel):
+        first: int
+
+    class SecondNumber(BaseModel):
+        second: int
+
+    @staticmethod
+    def add_pydantic_args(a: FirstNumber, b: SecondNumber):
+        """
+        Add two numbers
+
+        Args:
+            a(FirstNumber): first number
+            b(SecondNumber): second number
+        """
+        return a.first + b.second