added server tests

Author: mishushakov

.github/workflows/pull_request.yml

@@ -14,6 +14,8 @@ on:
       - main
 
 jobs:
+  server-unit-tests:
+    uses: ./.github/workflows/server_tests.yml
   build-template:
     uses: ./.github/workflows/build_test_template.yml
     secrets:

.github/workflows/server_tests.yml

@@ -0,0 +1,34 @@
+name: Test Code Interpreter Server
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Server - Unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Parse .tool-versions
+        uses: wistia/parse-tool-versions@v2.1.1
+        with:
+          filename: '.tool-versions'
+          uppercase: 'true'
+          prefix: 'tool_version_'
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: '${{ env.TOOL_VERSION_PYTHON }}'
+
+      - name: Install server dependencies
+        run: pip install -r template/server/requirements.txt
+
+      - name: Run server unit tests
+        working-directory: template/server
+        run: python -m pytest tests/ -v

template/server/tests/test_lock_release.py

@@ -0,0 +1,75 @@
+"""
+Regression test for issue #213: asyncio.Lock not released on client disconnect.
+
+The lock in ContextWebSocket.execute() must only be held while sending the
+request to the Jupyter kernel, NOT during the entire streaming phase. Holding
+it during streaming means a client disconnect leaves the lock held until the
+kernel finishes — blocking all subsequent executions on the same context.
+
+This test mocks the Jupyter WebSocket so no real kernel is needed.
+"""
+
+import asyncio
+import sys
+import os
+import unittest
+from unittest.mock import AsyncMock
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from messaging import ContextWebSocket
+from api.models.output import NumberOfExecutions
+
+
+class TestLockRelease(unittest.IsolatedAsyncioTestCase):
+    async def test_lock_not_held_during_streaming(self):
+        """Lock must be released before streaming results, not after."""
+        ws = ContextWebSocket("test-ctx", "test-session", "python", "/home/user")
+
+        # Mock the WebSocket so we don't need a real Jupyter kernel.
+        ws._ws = AsyncMock()
+        ws._ws.send = AsyncMock()
+
+        # Pre-set global env vars so execute() doesn't call get_envs().
+        ws._global_env_vars = {}
+
+        # Start the execute() generator.
+        gen = ws.execute("print('hello')", env_vars={}, access_token="")
+
+        # Drive the generator: it acquires the lock, sends the request, then
+        # enters _wait_for_result which blocks on queue.get(). We feed an item
+        # into the queue so the generator yields it back to us.
+        async def pull_first_item():
+            return await gen.__anext__()
+
+        pull_task = asyncio.create_task(pull_first_item())
+
+        # Wait for the generator to register the execution and send the request.
+        await asyncio.sleep(0.1)
+
+        # Feed an item into the execution queue so _wait_for_result yields.
+        assert len(ws._executions) == 1
+        message_id = list(ws._executions.keys())[0]
+        await ws._executions[message_id].queue.put(
+            NumberOfExecutions(execution_count=1)
+        )
+
+        # Get the yielded item — generator is now suspended at the next
+        # queue.get() inside _wait_for_result (the streaming phase).
+        await asyncio.wait_for(pull_task, timeout=2.0)
+
+        # THE KEY ASSERTION: the lock must NOT be held during streaming.
+        # Without fix: lock is held for entire execute() -> locked() is True -> FAIL
+        # With fix: lock released after send -> locked() is False -> PASS
+        assert not ws._lock.locked(), (
+            "Lock is held during result streaming — issue #213: if the client "
+            "disconnects now, the lock stays held and blocks all subsequent "
+            "executions on this context"
+        )
+
+        # Cleanup: close the generator properly.
+        await gen.aclose()
+
+
+if __name__ == "__main__":
+    unittest.main()