Skip to content

serejaris/telegram-skills / skills/tg-bot-ops

tg-bot-ops

Verified

Use when running a Telegram bot in production: webhook or long polling, allowed_updates, webhook secret token, privacy mode, 429 and retry_after, file retries, broadcast limits and paid broadcasts, lost updates on shutdown, a poison update after new Bot API types, t.me outage and fallback domains, local Bot API server.

FileKindSize
SKILL.mdskill md11.5 KB
scripts/retry_policy.pyscript2.8 KB
tests/test_retry_policy.pyscript6.4 KB

tests/test_retry_policy.py

View on GitHub
import importlib.util
import io
import json
from pathlib import Path
import sys
import unittest

SPEC = importlib.util.spec_from_file_location('retry_policy', Path(__file__).parents[1] / 'scripts/retry_policy.py')
policy = importlib.util.module_from_spec(SPEC)
sys.modules['retry_policy'] = policy
SPEC.loader.exec_module(policy)


def body(**fields):
    return json.dumps(fields)


LIMITED = (429, body(ok=False, error_code=429, description='Too Many Requests',
                     parameters={'retry_after': 7}))
SENT = (200, body(ok=True, result={'message_id': 1}))


class Clock:
    def __init__(self):
        self.now = 100
        self.slept = []

    def __call__(self):
        return self.now

    def sleep(self, seconds):
        self.slept.append(seconds)
        self.now += seconds


class Classify(unittest.TestCase):
    def test_success(self):
        decision = policy.classify(*SENT)
        self.assertEqual((decision.action, decision.result), (policy.DONE, {'message_id': 1}))

    def test_retry_after_is_honored(self):
        decision = policy.classify(*LIMITED)
        self.assertEqual((decision.action, decision.wait), (policy.RETRY, 7))

    def test_bad_retry_after_falls_back(self):
        for value in (None, 0, -5, '7', True, 1.5):
            params = {'retry_after': value}
            decision = policy.classify(429, body(ok=False, parameters=params))
            self.assertEqual((decision.action, decision.wait), (policy.RETRY, policy.DEFAULT_WAIT))
        self.assertEqual(policy.classify(429, body(ok=False, parameters='x')).wait, policy.DEFAULT_WAIT)

    def test_huge_retry_after_is_kept(self):
        decision = policy.classify(429, body(ok=False, parameters={'retry_after': 7200}))
        self.assertEqual((decision.action, decision.wait), (policy.RETRY, 7200))

    def test_group_migration(self):
        decision = policy.classify(400, body(ok=False, parameters={'migrate_to_chat_id': -1001234567890}))
        self.assertEqual((decision.action, decision.chat_id), (policy.MIGRATE, -1001234567890))

    def test_rejected_requests_fail(self):
        for status in (400, 401, 403, 404):
            self.assertEqual(policy.classify(status, body(ok=False, description='no')).action, policy.FAIL)

    def test_unclear_outcomes_are_unknown(self):
        for status, raw in ((500, body(ok=False)), (502, '<html>bad gateway</html>'), (200, 'not json'),
                            (200, '[]'), (200, 'null'), (200, ''), (200, None), (200, b'\xff'),
                            (200, body(ok=False)), (None, body(ok=True)), ('200', body(ok=True))):
            with self.subTest(status=status, raw=raw):
                self.assertEqual(policy.classify(status, raw).action, policy.UNKNOWN)


class Gate(unittest.TestCase):
    def test_finished_request_does_not_lift_the_pause(self):
        clock = Clock()
        gate = policy.FloodGate(clock, clock.sleep)
        gate.hold('chat:1', 10)
        clock.now = 103
        self.assertEqual(gate.delay('chat:1'), 7)
        self.assertEqual(gate.delay('chat:2'), 0)
        clock.now = 111
        self.assertEqual(gate.delay('chat:1'), 0)

    def test_shorter_wait_does_not_shrink_the_pause(self):
        clock = Clock()
        gate = policy.FloodGate(clock, clock.sleep)
        gate.hold('bot', 10)
        clock.now = 101
        gate.hold('bot', 1)
        self.assertEqual(gate.delay('bot'), 9)


class Send(unittest.TestCase):
    def run_send(self, responses, make_request=None, **kwargs):
        clock = Clock()
        queue = list(responses)
        seen = []

        def transport(request):
            seen.append(request)
            item = queue.pop(0)
            if isinstance(item, Exception):
                raise item
            return item

        decision = policy.send(make_request or (lambda: 'request'), transport,
                               policy.FloodGate(clock, clock.sleep), 'chat:1', **kwargs)
        return decision, seen, clock

    def test_multipart_is_rebuilt_for_every_attempt(self):
        built = []

        def make_request():
            stream = io.BytesIO(b'file bytes')
            built.append(stream)
            return stream

        def consuming_transport(stream):
            data = stream.read()
            self.assertEqual(data, b'file bytes')
            return LIMITED if len(built) == 1 else SENT

        clock = Clock()
        decision = policy.send(make_request, consuming_transport,
                               policy.FloodGate(clock, clock.sleep), 'chat:1')
        self.assertEqual(decision.action, policy.DONE)
        self.assertEqual(len(built), 2)
        self.assertEqual(clock.slept, [7])

    def test_timeout_is_not_retried(self):
        decision, seen, _ = self.run_send([TimeoutError('read timed out'), SENT])
        self.assertEqual(decision.action, policy.UNKNOWN)
        self.assertEqual(len(seen), 1)

    def test_server_error_is_not_retried(self):
        decision, seen, _ = self.run_send([(502, 'bad gateway'), SENT])
        self.assertEqual(decision.action, policy.UNKNOWN)
        self.assertEqual(len(seen), 1)

    def test_any_transport_exception_is_unknown(self):
        for error in (ValueError('library timeout'), KeyError('incomplete read')):
            decision, seen, _ = self.run_send([error, SENT])
            self.assertEqual(decision.action, policy.UNKNOWN)
            self.assertEqual(len(seen), 1)

    def test_failed_request_build_is_raised_and_sends_nothing(self):
        def make_request():
            raise FileNotFoundError('photo.jpg')

        with self.assertRaises(FileNotFoundError):
            self.run_send([SENT], make_request=make_request)

    def test_long_pause_returns_to_the_caller_with_the_server_wait(self):
        limited = (429, body(ok=False, parameters={'retry_after': 7200}))
        decision, seen, clock = self.run_send([limited, SENT])
        self.assertEqual((decision.action, decision.wait), (policy.FAIL, 7200))
        self.assertEqual(len(seen), 1)
        self.assertEqual(clock.slept, [])

    def test_gives_up_after_max_attempts(self):
        decision, seen, clock = self.run_send([LIMITED, LIMITED], max_attempts=2)
        self.assertEqual(decision.action, policy.FAIL)
        self.assertEqual(len(seen), 2)
        self.assertEqual(clock.slept, [7])

    def test_bad_max_attempts(self):
        for value in (0, -1, '3', True):
            with self.assertRaises(ValueError):
                self.run_send([SENT], max_attempts=value)


if __name__ == '__main__':
    unittest.main()
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall