Integration testing framework

dev/integration/env.TEMPLATE

@@ -0,0 +1,3 @@
+aioresponses
+microsoft-agents-activity
+microsoft-agents-hosting-core

dev/integration/integration_tests/test_quickstart.py

@@ -0,0 +1,44 @@
+import pytest
+import asyncio
+
+from ..core import integration
+
+
+@integration(service_url="http://localhost:3978/api/messages")
+class TestQuickstart:
+
+    @pytest.mark.asyncio
+    async def test_quickstart_functionality(self, agent_client, response_client):
+        await agent_client.send("hi")
+        await asyncio.sleep(2)
+        response = (await response_client.pop())[0]
+        assert "hello" in response.text.lower()
+
+
+# class TestQuickstart(TestSuiteBase):
+
+#     @pytest.mark.asyncio
+#     async def test_quickstart_functionality(self):
+#         pass
+
+# @integration(QuickstartSample, None) # env
+# class TestQuickstart:
+
+#     @pytest.mark.asyncio
+#     async def test_hello(self, agent_client, env):
+#         agent_client.send("hi")
+
+#         await asyncio.sleep(1)
+
+#         # assert env.auth...
+
+# @integration(app=None) # (endpoint="alternative")
+# class TestQuickstartAlternative:
+
+#     @pytest.mark.asyncio
+#     async def test_hello(self, agent_client, response_client):
+
+#         agent_client.send("hi")
+#         await asyncio.sleep(10)
+
+#         assert receiver.has_activity("hello")

dev/integration/requirements.txt

@@ -0,0 +1 @@
+aioresponses

dev/integration/src/core/__init__.py

@@ -0,0 +1,19 @@
+from .application_runner import ApplicationRunner
+from .client import (
+    AgentClient,
+    ResponseClient,
+)
+from .environment import Environment
+from .integration import integration, IntegrationFixtures
+from .sample import Sample
+
+
+__all__ = [
+    "AgentClient",
+    "ApplicationRunner",
+    "ResponseClient",
+    "Environment",
+    "integration",
+    "IntegrationFixtures",
+    "Sample",
+]

dev/integration/src/core/aiohttp/__init__.py

@@ -0,0 +1,4 @@
+from .aiohttp_environment import AiohttpEnvironment
+from .aiohttp_runner import AiohttpRunner
+
+__all__ = ["AiohttpEnvironment", "AiohttpRunner"]

dev/integration/src/core/aiohttp/aiohttp_environment.py

@@ -0,0 +1,57 @@
+from tkinter import E
+from aiohttp.web import Request, Response, Application, run_app
+
+from microsoft_agents.hosting.aiohttp import (
+    CloudAdapter,
+    jwt_authorization_middleware,
+    start_agent_process,
+)
+from microsoft_agents.hosting.core import (
+    Authorization,
+    AgentApplication,
+    TurnState,
+    MemoryStorage,
+)
+from microsoft_agents.authentication.msal import MsalConnectionManager
+from microsoft_agents.activity import load_configuration_from_env
+
+from ..application_runner import ApplicationRunner
+from ..environment import Environment
+
+
+class AiohttpEnvironment(Environment):
+    """An environment for aiohttp-hosted agents."""
+
+    async def init_env(self, environ_config: dict) -> None:
+        environ_config = environ_config or {}
+
+        self.config = load_configuration_from_env(environ_config)
+
+        self.storage = MemoryStorage()
+        self.connection_manager = MsalConnectionManager(**self.config)
+        self.adapter = CloudAdapter(connection_manager=self.connection_manager)
+        self.authorization = Authorization(
+            self.storage, self.connection_manager, **self.config
+        )
+
+        self.agent_application = AgentApplication[TurnState](
+            storage=self.storage,
+            adapter=self.adapter,
+            authorization=self.authorization,
+            **self.config
+        )
+
+    def create_runner(self) -> ApplicationRunner:
+
+        async def entry_point(req: Request) -> Response:
+            agent: AgentApplication = req.app["agent_app"]
+            adapter: CloudAdapter = req.app["adapter"]
+            return await start_agent_process(req, agent, adapter)
+
+        APP = Application(middlewares=[jwt_authorization_middleware])
+        APP.router.add_post("/api/messages", entry_point)
+        APP["agent_configuration"] = self.connection_manager.get_default_connection()
+        APP["agent_app"] = self.agent_application
+        APP["adapter"] = self.adapter
+
+        return AiohttpRunner(APP)

dev/integration/src/core/aiohttp/aiohttp_runner.py

@@ -0,0 +1,115 @@
+from typing import Optional
+from typing import Optional
+from threading import Thread, Event
+import asyncio
+
+from aiohttp import ClientSession
+from aiohttp.web import Application, Request, Response
+from aiohttp.web_runner import AppRunner, TCPSite
+
+from ..application_runner import ApplicationRunner
+
+
+class AiohttpRunner(ApplicationRunner):
+    """A runner for aiohttp applications."""
+
+    def __init__(self, app: Application, host: str = "localhost", port: int = 8000):
+        assert isinstance(app, Application)
+        super().__init__(app)
+
+        url = f"{host}:{port}"
+        self._host = host
+        self._port = port
+        if "http" not in url:
+            url = f"http://{url}"
+        self._url = url
+
+        self._app.router.add_get("/shutdown", self._shutdown_route)
+
+        self._server_thread: Optional[Thread] = None
+        self._shutdown_event = Event()
+        self._runner: Optional[AppRunner] = None
+        self._site: Optional[TCPSite] = None
+
+    @property
+    def url(self) -> str:
+        return self._url
+
+    async def _start_server(self) -> None:
+        try:
+            assert isinstance(self._app, Application)
+
+            self._runner = AppRunner(self._app)
+            await self._runner.setup()
+            self._site = TCPSite(self._runner, self._host, self._port)
+            await self._site.start()
+
+            # Wait for shutdown signal
+            while not self._shutdown_event.is_set():
+                await asyncio.sleep(0.1)
+
+            # Cleanup
+            await self._site.stop()
+            await self._runner.cleanup()
+
+        except Exception as error:
+            raise error
+
+    async def __aenter__(self):
+        if self._server_thread:
+            raise RuntimeError("ResponseClient is already running.")
+
+        self._shutdown_event.clear()
+        self._server_thread = Thread(
+            target=lambda: asyncio.run(self._start_server()), daemon=True
+        )
+        self._server_thread.start()
+
+        # Wait a moment to ensure the server starts
+        await asyncio.sleep(0.5)
+
+        return self
+
+    async def _stop_server(self):
+        if not self._server_thread:
+            raise RuntimeError("ResponseClient is not running.")
+
+        try:
+            async with ClientSession() as session:
+                async with session.get(
+                    f"http://{self._host}:{self._port}/shutdown"
+                ) as response:
+                    pass  # Just trigger the shutdown
+        except Exception:
+            pass  # Ignore errors during shutdown request
+
+        # Set shutdown event as fallback
+        self._shutdown_event.set()
+
+        # Wait for the server thread to finish
+        self._server_thread.join(timeout=5.0)
+        self._server_thread = None
+
+    async def _shutdown_route(self, request: Request) -> Response:
+        """Handle shutdown request by setting the shutdown event"""
+        self._shutdown_event.set()
+        return Response(status=200, text="Shutdown initiated")
+
+    async def __aexit__(self, exc_type, exc, tb):
+        if not self._server_thread:
+            raise RuntimeError("ResponseClient is not running.")
+        try:
+            async with ClientSession() as session:
+                async with session.get(
+                    f"http://{self._host}:{self._port}/shutdown"
+                ) as response:
+                    pass  # Just trigger the shutdown
+        except Exception:
+            pass  # Ignore errors during shutdown request
+
+        # Set shutdown event as fallback
+        self._shutdown_event.set()
+
+        # Wait for the server thread to finish
+        self._server_thread.join(timeout=5.0)
+        self._server_thread = None

dev/integration/src/core/application_runner.py

@@ -0,0 +1,42 @@
+import asyncio
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+from threading import Thread
+
+
+class ApplicationRunner(ABC):
+    """Base class for application runners."""
+
+    def __init__(self, app: Any):
+        self._app = app
+        self._thread: Optional[Thread] = None
+
+    @abstractmethod
+    async def _start_server(self) -> None:
+        raise NotImplementedError(
+            "Start server method must be implemented by subclasses"
+        )
+
+    async def _stop_server(self) -> None:
+        pass
+
+    async def __aenter__(self) -> None:
+
+        if self._thread:
+            raise RuntimeError("Server is already running")
+
+        def target():
+            asyncio.run(self._start_server())
+
+        self._thread = Thread(target=target, daemon=True)
+        self._thread.start()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+
+        if self._thread:
+            await self._stop_server()
+
+            self._thread.join()
+            self._thread = None
+        else:
+            raise RuntimeError("Server is not running")

dev/integration/src/core/client/__init__.py

@@ -0,0 +1,7 @@
+from .agent_client import AgentClient
+from .response_client import ResponseClient
+
+__all__ = [
+    "AgentClient",
+    "ResponseClient",
+]