import asyncio import json import unittest from concurrent.futures import ThreadPoolExecutor from dataclasses import replace from unittest.mock import patch from src.errors import APIError from src.limits import Limits, ResourceLimitMiddleware from src.store import InMemoryStore class StoreLimitTests(unittest.TestCase): def make_store(self, **values): store = InMemoryStore(replace(Limits(), **values)) actor = store.create_user('alice', 'Alice')['id'] chat = store.create_chat(actor, 'Chat', [actor])['id'] return store, actor, chat def test_capacity_is_atomic_and_does_not_evict(self): store, actor, chat = self.make_store(max_messages=20) def send(i): try: return store.create_message(chat, actor, str(i)) except APIError as exc: self.assertEqual(exc.status_code, 503) return None with ThreadPoolExecutor(max_workers=10) as pool: accepted = [item for item in pool.map(send, range(100)) if item] self.assertEqual(len(accepted), 20) page = store.list_messages(chat, actor, 100, None) self.assertEqual({item['id'] for item in page['items']}, {item['id'] for item in accepted}) def test_byte_limit_counts_utf8_and_other_objects_are_bounded(self): store, actor, chat = self.make_store(max_text_bytes=4, max_users=1, max_chats=1) saved = store.create_message(chat, actor, '🙂') for operation in [lambda: store.create_message(chat, actor, 'a'), lambda: store.create_user('bob', 'Bob'), lambda: store.create_chat(actor, 'Other', [actor])]: with self.assertRaises(APIError) as error: operation() self.assertEqual(error.exception.status_code, 503) self.assertEqual(store.list_messages(chat, actor, 100, None)['items'], [saved]) def test_rate_recovers_without_losing_messages(self): with patch('src.store.time.monotonic', return_value=0) as clock: store, actor, chat = self.make_store(message_rate=2, message_burst=1) first = store.create_message(chat, actor, 'one') with self.assertRaises(APIError) as error: store.create_message(chat, actor, 'rejected') self.assertEqual(error.exception.status_code, 429) clock.return_value = 0.5 second = store.create_message(chat, actor, 'two') self.assertEqual(store.list_messages(chat, actor, 100, None)['items'], sorted([first, second], key=lambda item: (item['created_at'], item['id']))) class MiddlewareLimitTests(unittest.IsolatedAsyncioTestCase): async def call(self, app, chunks, headers=()): messages = iter(chunks) output = [] async def receive(): return next(messages) async def send(message): output.append(message) scope = {'type': 'http', 'path': '/api/v1/users', 'method': 'POST', 'headers': headers, 'state': {'request_id': 'limit-test'}} await app(scope, receive, send) return output async def test_body_limit_with_and_without_content_length(self): async def should_not_run(scope, receive, send): self.fail('Oversized body reached the API') app = ResourceLimitMiddleware(should_not_run, replace(Limits(), max_request_bytes=4)) for headers, chunks in [([(b'content-length', b'5')], []), ([], [ {'type': 'http.request', 'body': b'123', 'more_body': True}, {'type': 'http.request', 'body': b'45', 'more_body': False}])]: result = await self.call(app, chunks, headers) self.assertEqual(result[0]['status'], 413) self.assertEqual(json.loads(result[1]['body'])['error']['request_id'], 'limit-test') self.assertEqual(app.active, 0) async def test_admission_recovers_after_inflight_request_finishes(self): entered, release = asyncio.Event(), asyncio.Event() async def slow_app(scope, receive, send): entered.set() await release.wait() await send({'type': 'http.response.start', 'status': 200, 'headers': []}) app = ResourceLimitMiddleware(slow_app, replace(Limits(), max_inflight=1)) body = [{'type': 'http.request', 'body': b'', 'more_body': False}] first = asyncio.create_task(self.call(app, body)) await entered.wait() overloaded = await self.call(app, body) self.assertEqual(overloaded[0]['status'], 503) release.set() await first self.assertEqual((await self.call(app, body))[0]['status'], 200) self.assertEqual(app.active, 0) async def test_exception_releases_slot(self): async def broken_app(scope, receive, send): raise RuntimeError('test') app = ResourceLimitMiddleware(broken_app) with self.assertRaises(RuntimeError): await self.call(app, [{'type': 'http.request', 'body': b''}]) self.assertEqual(app.active, 0)