107 lines
5.0 KiB
Python
107 lines
5.0 KiB
Python
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)
|