Files
mtusi2026lab3/student-tests/test_event_loop.py
T

133 lines
6.2 KiB
Python

#!/usr/bin/env python3
"""Regression: blocking boundaries must execute off the ASGI event-loop thread.
Run inside the API image; no DB queries, external clients or extra dependencies.
"""
import asyncio
from collections import defaultdict
from contextlib import ExitStack
from datetime import datetime, timezone
import json
import threading
import unittest
from unittest.mock import patch
from uuid import UUID
from psycopg import OperationalError
from src import main
USER_ID = '11111111-1111-4111-8111-111111111111'
CHAT_ID = '22222222-2222-4222-8222-222222222222'
USER = {'id': USER_ID, 'username': 'synthetic', 'display_name': 'Synthetic', 'created_at': '2026-11-06T00:00:00Z'}
CHAT = {'id': CHAT_ID, 'title': 'Synthetic', 'member_ids': [USER_ID], 'created_at': USER['created_at']}
MESSAGE = {'id': '33333333-3333-4333-8333-333333333333', 'chat_id': CHAT_ID, 'sender_id': USER_ID, 'text': 'test', 'created_at': USER['created_at']}
async def request(method, path, body=None, headers=None):
encoded = json.dumps(body).encode() if body is not None else b''
request_headers = {'host': 'test', 'authorization': 'Bearer ' + 'a'*43}
if body is not None:
request_headers['content-type'] = 'application/json'
request_headers.update(headers or {})
scope = {'type': 'http', 'asgi': {'version': '3.0', 'spec_version': '2.4'},
'http_version': '1.1', 'method': method, 'scheme': 'http',
'path': path, 'raw_path': path.encode(), 'query_string': b'',
'root_path': '', 'server': ('test', 80), 'client': ('127.0.0.1', 1234),
'headers': [(k.encode(), v.encode()) for k, v in request_headers.items()]}
sent = []
received = False
async def receive():
nonlocal received
if not received:
received = True
return {'type': 'http.request', 'body': encoded, 'more_body': False}
await asyncio.Event().wait()
async def send(message):
sent.append(message)
await asyncio.wait_for(main.app(scope, receive, send), timeout=5)
start = next(m for m in sent if m['type'] == 'http.response.start')
data = b''.join(m.get('body', b'') for m in sent if m['type'] == 'http.response.body')
return start['status'], dict(start['headers']), json.loads(data) if data else None
class EventLoopTests(unittest.IsolatedAsyncioTestCase):
async def asyncSetUp(self):
self.loop_thread = threading.get_ident()
self.calls = defaultdict(list)
self.stack = ExitStack()
self.addCleanup(self.stack.close)
def blocking(self, name, result=None, error=None):
def spy(*args, **kwargs):
self.calls[name].append(threading.get_ident())
if error:
raise error
return result
self.stack.enter_context(patch.object(main, name, side_effect=spy))
def assert_off_loop(self, *names):
for name in names:
self.assertTrue(self.calls[name], name + ' was not exercised')
self.assertNotIn(self.loop_thread, self.calls[name], name + ' blocked the event loop')
async def test_registration_hash_and_insert(self):
self.blocking('hash_password', 'synthetic-hash')
self.blocking('insert_user', USER)
status, headers, _ = await request('POST', '/api/v1/users',
{'username': 'synthetic', 'display_name': 'Synthetic', 'password': 'synthetic-password'})
self.assertEqual(status, 201)
self.assertIn(b'x-instance-id', headers)
self.assert_off_loop('hash_password', 'insert_user')
async def test_login_lookup_verify_and_session(self):
import base64
row = {**USER, 'id': UUID(USER_ID), 'password_hash': 'synthetic-hash', 'created_at': datetime.now(timezone.utc)}
self.blocking('find_user_by_username', row)
self.blocking('verify_password', True)
self.blocking('create_session')
basic = base64.b64encode(b'synthetic:synthetic-password').decode()
status, _, _ = await request('POST', '/api/v1/auth/sessions', headers={'authorization': 'Basic '+basic})
self.assertEqual(status, 201)
self.assert_off_loop('find_user_by_username', 'verify_password', 'create_session')
async def test_chat_session_and_transaction(self):
self.blocking('find_session_user_cached', USER)
self.blocking('insert_chat', CHAT)
status, _, _ = await request('POST', '/api/v1/chats', {'title': 'Synthetic', 'member_ids': [USER_ID]})
self.assertEqual(status, 201)
self.assert_off_loop('find_session_user_cached', 'insert_chat')
async def test_message_session_access_and_atomic_insert(self):
self.blocking('find_session_user_cached', USER)
self.blocking('find_chat', CHAT)
self.blocking('insert_message', MESSAGE)
status, _, _ = await request('POST', '/api/v1/chats/'+CHAT_ID+'/messages', {'text': 'test'}, {'idempotency-key': 'test-key'})
self.assertEqual(status, 201)
self.assert_off_loop('find_session_user_cached', 'find_chat', 'insert_message')
async def test_lifecycle_pool_open_and_close(self):
self.blocking('open_database')
self.blocking('close_database')
await main.app.router.startup()
await main.app.router.shutdown()
self.assert_off_loop('open_database', 'close_database')
async def test_openapi_does_not_read_file_in_request(self):
with patch('pathlib.Path.read_text', side_effect=AssertionError('Disk I/O during HTTP request')):
status, _, data = await request('GET', '/openapi.json')
self.assertEqual(status, 200)
self.assertEqual(data['info']['version'], '1.3.0')
async def test_thread_exception_preserves_error_contract(self):
self.blocking('hash_password', 'synthetic-hash')
self.blocking('insert_user', error=OperationalError('synthetic outage'))
status, headers, data = await request('POST', '/api/v1/users',
{'username': 'synthetic', 'display_name': 'Synthetic', 'password': 'synthetic-password'})
self.assertEqual(status, 503)
self.assertEqual(data['error']['code'], 'unavailable')
self.assertEqual(data['error']['request_id'], headers[b'x-request-id'].decode())
self.assert_off_loop('hash_password', 'insert_user')
if __name__ == '__main__':
unittest.main(verbosity=2)