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,43 @@
+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,20 @@
+from .application_runner import ApplicationRunner
+from .client import (
+    AgentClient,
+    ResponseClient,
+)
+from .environment import Environment
+from .integration import integration
+from .integration_fixtures import IntegrationFixtures
+from .sample import Sample
+
+
+__all__ = [
+    "AgentClient",
+    "ApplicationRunner",
+    "ResponseClient",
+    "Environment",
+    "integration",
+    "IntegrationFixtures",
+    "Sample",
+]

dev/integration/src/core/application_runner.py

@@ -0,0 +1,35 @@
+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
+    def _start_server(self) -> None:
+        raise NotImplementedError("Start server method must be implemented by subclasses")
+
+    def _stop_server(self) -> None:
+        pass
+
+    async def __aenter__(self) -> None:
+
+        if self._thread:
+            raise RuntimeError("Server is already running")
+
+        self._thread = Thread(target=self._start_server, daemon=True)
+        self._thread.start()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+
+        if self._thread:
+            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",
+]

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

@@ -0,0 +1,107 @@
+import os
+import json
+import asyncio
+from typing import Any, Optional, cast
+
+from aiohttp import ClientSession
+
+from microsoft_agents.activity import (
+    Activity,
+    ActivityTypes,
+    DeliveryModes
+)
+
+from msal import ConfidentialClientApplication
+
+class AgentClient:
+
+    def __init__(
+            self,
+            messaging_endpoint: str,
+            service_endpoint: str,
+            cid: str,
+            client_id: str,
+            tenant_id: str,
+            client_secret: str,
+            default_timeout: float = 5.0
+        ):
+        self._messaging_endpoint = messaging_endpoint
+        self.service_endpoint = service_endpoint
+        self.cid = cid
+        self.client_id = client_id
+        self.tenant_id = tenant_id
+        self.client_secret = client_secret
+        self._headers = None
+        self._default_timeout = default_timeout
+
+        self._client = ClientSession(
+            base_url=self._messaging_endpoint,
+            headers={"Content-Type": "application/json"}
+        )
+
+        self._msal_app = ConfidentialClientApplication(
+            client_id=client_id,
+            client_credential=client_secret,
+            authority=f"https://login.microsoftonline.com/{tenant_id}"
+        )
+
+    async def get_access_token(self) -> str:
+        res = self._msal_app.acquire_token_for_client(
+            scopes=[f"{self.client_id}/.default"]
+        )
+        token = res.get("access_token") if res else None
+        if not token:
+            raise Exception("Could not obtain access token")
+        return token
+
+    async def _set_headers(self) -> None:
+        if not self._headers:
+            token = await self.get_access_token()
+            self._headers = {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json"
+            }
+
+    async def send_request(self, activity: Activity) -> str:
+
+        await self._set_headers()
+
+        if activity.conversation:
+            activity.conversation.id = self.cid
+
+        async with self._client.post(
+            self._messaging_endpoint,
+            headers=self._headers,
+            json=activity.model_dump(by_alias=True, exclude_none=True)
+        ) as response:
+            if not response.ok:
+                raise Exception(f"Failed to send activity: {response.status}")
+            content = await response.text()
+            return content
+
+    def _to_activity(self, activity_or_text: Activity | str) -> Activity:
+        if isinstance(activity_or_text, str):
+            activity = Activity(
+                type=ActivityTypes.message,
+                text=activity_or_text,
+            )
+            return activity
+        else:
+            return cast(Activity, activity_or_text)
+
+    async def send_activity(self, activity_or_text: Activity | str, timeout: Optional[float] = None) -> str:
+        timeout = timeout or self._default_timeout
+        activity = self._to_activity(activity_or_text)
+        content = await self.send_request(activity)
+        return content
+
+    async def send_expect_replies(self, activity_or_text: Activity | str, timeout: Optional[float] = None) -> list[Activity]:
+        timeout = timeout or self._default_timeout
+        activity = self._to_activity(activity_or_text)
+        activity.delivery_mode = DeliveryModes.expect_replies
+
+        content = await self.send_request(activity)
+
+        activities_data = json.loads(content).get("activities", [])
+        activities = [Activity.model_validate(act) for act in activities_data]
+        return activities

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

@@ -0,0 +1,18 @@
+# from microsoft_agents.activity import Activity
+
+# from ..agent_client import AgentClient
+
+# class AutoClient:
+
+#     def __init__(self, agent_client: AgentClient):
+#         self._agent_client = agent_client
+
+#     async def generate_message(self) -> str:
+#         pass
+
+#     async def run(self, max_turns: int = 10, time_between_turns: float = 2.0) -> None:
+
+#         for i in range(max_turns):
+#             await self._agent_client.send_activity(
+#                 Activity(type="message", text=self.generate_message())
+#             )