Fix CI test failures - streaming, rule objects, and port conflicts

- Fix StreamResponse.prepare() missing request argument in server.py:252
- Update tests to use Rule objects instead of dicts for type safety
- Use dynamic port allocation (port=0) to avoid binding conflicts
- All 14 tests now pass successfully

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: haasonsaas

src/mocktopus/server.py

@@ -88,13 +88,13 @@ async def handle_openai_chat(self, request: Request) -> Union[Response, StreamRe
 
         # Mode-specific handling
         if self.mode == ServerMode.MOCK:
-            return await self._handle_mock_openai(model, messages, stream, data)
+            return await self._handle_mock_openai(request, model, messages, stream, data)
         elif self.mode == ServerMode.RECORD:
             return await self._handle_record_openai(data, stream)
         elif self.mode == ServerMode.REPLAY:
             return await self._handle_replay_openai(data, stream)
 
-    async def _handle_mock_openai(self, model: str, messages: List[Dict],
+    async def _handle_mock_openai(self, request: Request, model: str, messages: List[Dict],
                                   stream: bool, full_request: Dict) -> Union[Response, StreamResponse]:
         """Handle mocked OpenAI responses using scenarios"""
 
@@ -136,7 +136,7 @@ async def _handle_mock_openai(self, model: str, messages: List[Dict],
 
         # Stream response
         if stream:
-            return await self._stream_openai_response(content, model, tool_calls)
+            return await self._stream_openai_response(request, content, model, tool_calls)
 
         # Regular response
         response_data = {
@@ -240,7 +240,7 @@ async def _handle_error_response(self, error_config: Dict[str, Any]) -> Response
                 status=status_code
             )
 
-    async def _stream_openai_response(self, content: str, model: str,
+    async def _stream_openai_response(self, request: Request, content: str, model: str,
                                       tool_calls: List[Dict] = None) -> StreamResponse:
         """Stream OpenAI response using Server-Sent Events"""
 
@@ -249,7 +249,7 @@ async def _stream_openai_response(self, content: str, model: str,
         response.headers['Cache-Control'] = 'no-cache'
         response.headers['X-Accel-Buffering'] = 'no'
 
-        await response.prepare()
+        await response.prepare(request)
 
         # Stream ID
         stream_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"

tests/test_integration.py

@@ -13,26 +13,31 @@
 from mocktopus import Scenario, load_yaml
 from mocktopus.server import MockServer, ServerMode
 from mocktopus.cost_tracker import CostTracker
+from mocktopus.core import Rule
 
 
 @pytest.fixture
 async def mock_server():
     """Start a mock server for testing"""
     scenario = Scenario()
-    scenario.rules.append({
-        "type": "llm.openai",
-        "when": {"messages_contains": "hello"},
-        "respond": {"content": "Hello from mock!", "usage": {"input_tokens": 5, "output_tokens": 4}}
-    })
-
-    server = MockServer(scenario=scenario, port=8089, host="127.0.0.1")
+    scenario.rules.append(Rule(
+        type="llm.openai",
+        when={"messages_contains": "hello"},
+        respond={"content": "Hello from mock!", "usage": {"input_tokens": 5, "output_tokens": 4}}
+    ))
+
+    # Use port 0 to get a random available port
+    server = MockServer(scenario=scenario, port=0, host="127.0.0.1")
     app = server.create_app()
 
     runner = aiohttp.web.AppRunner(app)
     await runner.setup()
-    site = aiohttp.web.TCPSite(runner, "127.0.0.1", 8089)
+    site = aiohttp.web.TCPSite(runner, "127.0.0.1", 0)
     await site.start()
 
+    # Update server port with the actual port that was bound
+    server.port = site._server.sockets[0].getsockname()[1]
+
     yield server
 
     await runner.cleanup()
@@ -44,7 +49,7 @@ async def test_basic_chat_completion(mock_server):
     async with aiohttp.ClientSession() as session:
         # Test successful request
         async with session.post(
-            "http://localhost:8089/v1/chat/completions",
+            f"http://localhost:{mock_server.port}/v1/chat/completions",
             json={
                 "model": "gpt-4",
                 "messages": [{"role": "user", "content": "hello"}]
@@ -57,7 +62,7 @@ async def test_basic_chat_completion(mock_server):
 
         # Test no match
         async with session.post(
-            "http://localhost:8089/v1/chat/completions",
+            f"http://localhost:{mock_server.port}/v1/chat/completions",
             json={
                 "model": "gpt-4",
                 "messages": [{"role": "user", "content": "unknown"}]
@@ -70,18 +75,21 @@ async def test_basic_chat_completion(mock_server):
 async def test_streaming_response():
     """Test SSE streaming response"""
     scenario = load_yaml("examples/chat-basic.yaml")
-    server = MockServer(scenario=scenario, port=8090)
+    server = MockServer(scenario=scenario, port=0)
     app = server.create_app()
 
     runner = aiohttp.web.AppRunner(app)
     await runner.setup()
-    site = aiohttp.web.TCPSite(runner, "127.0.0.1", 8090)
+    site = aiohttp.web.TCPSite(runner, "127.0.0.1", 0)
     await site.start()
 
+    # Update server port with the actual port that was bound
+    server.port = site._server.sockets[0].getsockname()[1]
+
     try:
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                "http://localhost:8090/v1/chat/completions",
+                f"http://localhost:{server.port}/v1/chat/completions",
                 json={
                     "model": "gpt-4",
                     "messages": [{"role": "user", "content": "hello"}],
@@ -274,11 +282,11 @@ def test_rule_matching():
     scenario = Scenario()
 
     # Test exact match
-    scenario.rules.append({
-        "type": "llm.openai",
-        "when": {"messages_contains": "weather"},
-        "respond": {"content": "It's sunny!"}
-    })
+    scenario.rules.append(Rule(
+        type="llm.openai",
+        when={"messages_contains": "weather"},
+        respond={"content": "It's sunny!"}
+    ))
 
     rule, response = scenario.find_llm(
         model="gpt-4",
@@ -289,11 +297,11 @@ def test_rule_matching():
 
     # Test regex match
     scenario.rules = []
-    scenario.rules.append({
-        "type": "llm.openai",
-        "when": {"messages_regex": r"\d+ \+ \d+"},
-        "respond": {"content": "Math detected"}
-    })
+    scenario.rules.append(Rule(
+        type="llm.openai",
+        when={"messages_regex": r"\d+ \+ \d+"},
+        respond={"content": "Math detected"}
+    ))
 
     rule, response = scenario.find_llm(
         model="gpt-4",
@@ -304,11 +312,11 @@ def test_rule_matching():
 
     # Test model glob match
     scenario.rules = []
-    scenario.rules.append({
-        "type": "llm.openai",
-        "when": {"model": "gpt-3.5*"},
-        "respond": {"content": "GPT-3.5 response"}
-    })
+    scenario.rules.append(Rule(
+        type="llm.openai",
+        when={"model": "gpt-3.5*"},
+        respond={"content": "GPT-3.5 response"}
+    ))
 
     rule, response = scenario.find_llm(
         model="gpt-3.5-turbo",
@@ -329,12 +337,12 @@ def test_usage_limits():
     """Test rule usage limits"""
     scenario = Scenario()
 
-    rule = {
-        "type": "llm.openai",
-        "when": {"messages_contains": "test"},
-        "respond": {"content": "Limited"},
-        "times": 2
-    }
+    rule = Rule(
+        type="llm.openai",
+        when={"messages_contains": "test"},
+        respond={"content": "Limited"},
+        times=2
+    )
     scenario.rules.append(rule)
 
     # Should work twice