mirror of
https://github.com/langbot-app/LangBot.git
synced 2026-08-08 12:20:58 +00:00
Junyan Qin
100 lines
2.9 KiB
Python
100 lines
2.9 KiB
Python
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from types import SimpleNamespace
|
|
from unittest.mock import AsyncMock
|
|
|
|
import pytest
|
|
|
|
from langbot.pkg.platform.webhook_pusher import WebhookPusher
|
|
|
|
|
|
pytestmark = pytest.mark.asyncio
|
|
|
|
|
|
def _application(max_inflight_requests: object) -> SimpleNamespace:
|
|
return SimpleNamespace(
|
|
instance_config=SimpleNamespace(
|
|
data={
|
|
'webhooks': {
|
|
'max_inflight_requests': max_inflight_requests,
|
|
}
|
|
}
|
|
),
|
|
logger=logging.getLogger(__name__),
|
|
)
|
|
|
|
|
|
async def test_delivery_admission_never_queues_above_instance_limit():
|
|
pusher = WebhookPusher(_application(2))
|
|
release = asyncio.Event()
|
|
both_started = asyncio.Event()
|
|
calls = 0
|
|
active = 0
|
|
peak_active = 0
|
|
|
|
async def fake_push(url: str, payload: dict) -> dict:
|
|
nonlocal calls, active, peak_active
|
|
calls += 1
|
|
active += 1
|
|
peak_active = max(peak_active, active)
|
|
if active == 2:
|
|
both_started.set()
|
|
try:
|
|
await release.wait()
|
|
return {'url': url}
|
|
finally:
|
|
active -= 1
|
|
|
|
pusher._push_to_webhook = fake_push
|
|
webhooks = [{'url': f'https://example.invalid/{index}'} for index in range(5)]
|
|
|
|
first_delivery = asyncio.create_task(pusher._push_to_webhooks(webhooks, {}))
|
|
await asyncio.wait_for(both_started.wait(), timeout=1)
|
|
second_results = await pusher._push_to_webhooks(webhooks, {})
|
|
release.set()
|
|
first_results = await first_delivery
|
|
|
|
assert len(first_results) == 2
|
|
assert second_results == []
|
|
assert calls == 2
|
|
assert peak_active == 2
|
|
assert pusher._inflight_requests == 0
|
|
|
|
|
|
async def test_cancelled_delivery_reaps_children_and_releases_slots():
|
|
pusher = WebhookPusher(_application(1))
|
|
started = asyncio.Event()
|
|
never = asyncio.Event()
|
|
|
|
async def blocking_push(url: str, payload: dict) -> dict:
|
|
started.set()
|
|
await never.wait()
|
|
return {}
|
|
|
|
pusher._push_to_webhook = blocking_push
|
|
delivery = asyncio.create_task(
|
|
pusher._push_to_webhooks([{'url': 'https://example.invalid'}], {}),
|
|
)
|
|
await asyncio.wait_for(started.wait(), timeout=1)
|
|
|
|
delivery.cancel()
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await delivery
|
|
|
|
assert pusher._inflight_requests == 0
|
|
pusher._push_to_webhook = AsyncMock(return_value={})
|
|
assert await pusher._push_to_webhooks([{'url': 'https://example.invalid'}], {}) == [{}]
|
|
|
|
|
|
async def test_max_inflight_requests_clamps_config():
|
|
pusher = WebhookPusher(_application(999999))
|
|
assert pusher._max_inflight_requests() == 128
|
|
|
|
pusher.ap.instance_config.data['webhooks']['max_inflight_requests'] = 0
|
|
assert pusher._max_inflight_requests() == 1
|
|
|
|
pusher.ap.instance_config.data['webhooks']['max_inflight_requests'] = 'invalid'
|
|
assert pusher._max_inflight_requests() == 16
|