where($key, $value); } } final class CloudInstanceQuery { private array $filters = []; public function where($key, $value) { $this->filters[$key] = $value; return $this; } public function first() { foreach (CloudInstance::$instances as $instance) { foreach ($this->filters as $key => $value) { if (($instance->$key ?? null) != $value) { continue 2; } } return $instance; } return null; } } final class TicketTelegramDelivery { public static array $rows = []; public static int $nextId = 1; public ?int $id = null; public string $binding_generation = ''; public int $bound_admin_id = 0; public string $chat_id = ''; public int $ticket_id = 0; public int $ticket_message_id = 0; public string $event_kind = ''; public ?int $telegram_message_id = null; public string $state = ''; public string $content_hash = ''; public int $created_at = 0; public ?int $sent_at = null; public int $updated_at = 0; public static function where($key, $value) { return (new TicketTelegramDeliveryQuery())->where($key, $value); } public function save() { if ($this->id === null) { foreach (self::$rows as $row) { if ($row->binding_generation === $this->binding_generation && $row->ticket_message_id === $this->ticket_message_id && $row->event_kind === $this->event_kind) { throw new \RuntimeException('synthetic duplicate delivery'); } } $this->id = self::$nextId++; } self::$rows[$this->id] = $this; return true; } } final class TicketTelegramDeliveryQuery { private array $filters = []; public function where($key, $value) { $this->filters[$key] = $value; return $this; } public function first() { foreach (TicketTelegramDelivery::$rows as $row) { if ($this->matches($row)) { return $row; } } return null; } public function update(array $values) { $updated = 0; foreach (TicketTelegramDelivery::$rows as $row) { if (!$this->matches($row)) { continue; } foreach ($values as $key => $value) { $row->$key = $value; } TicketTelegramDelivery::$rows[$row->id] = $row; $updated++; } return $updated; } public function delete() { $deleted = 0; foreach (TicketTelegramDelivery::$rows as $id => $row) { if ($this->matches($row)) { unset(TicketTelegramDelivery::$rows[$id]); $deleted++; } } return $deleted; } private function matches(TicketTelegramDelivery $row): bool { foreach ($this->filters as $key => $value) { if (($row->$key ?? null) != $value) { return false; } } return true; } } final class Configurations { public static array $rows = []; public static int $transactions = 0; public static int $locks = 0; public static int $writes = 0; public static int $queries = 0; public static bool $failQueries = false; public static bool $failWrites = false; public static mixed $bindingReadHook = null; public function __construct(public string $name = '', public string $value = '{}') {} public static function where($key, $value) { if (self::$failQueries) { throw new \RuntimeException('SQLSTATE synthetic-internal-detail'); } self::$queries++; return new \TelegramTestQuery($value); } public static function whereIn($key, $values) { if (self::$failQueries) { throw new \RuntimeException('SQLSTATE synthetic-internal-detail'); } self::$queries++; return new \TelegramTestWhereInQuery($values); } public function getConnection() { return new \TelegramTestConnection(); } public function save() { if (self::$failWrites) { return false; } self::$rows[$this->name] = $this; self::$writes++; return true; } } } namespace App\Services { final class Auth { public static $user; public static function getUser() { return self::$user; } } final class RedisClient { public static array $store = []; public static array $ttls = []; public static bool $fail = false; public static int $gets = 0; public static int $sets = 0; public static int $deletes = 0; public function __construct() { if (self::$fail) { throw new \RuntimeException('Redis unavailable'); } } public function getClient() { return new \TelegramTestRedisBackend(); } public function setex($key, $ttl, $value) { return $this->getClient()->setex($key, $ttl, $value); } public function del($key) { return $this->getClient()->del($key); } } } namespace App\Services\Cloud { final class CloudSecrets { public static int $calls = 0; public static function key(string $purpose): string { self::$calls++; return str_repeat("\x42", 32); } } } namespace App\Services\Telegram { require_once dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramDestination.php'; require_once dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramDeliveryChannel.php'; require_once dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramRateLimiter.php'; final class DatabaseAdministratorTelegramRateGate implements AdministratorTelegramRateLimiter { public static int $permits = 0; public static string $mode = 'ready'; public function acquire( AdministratorTelegramDestination $destination ): void { self::$permits++; if (self::$mode === 'backlog') { throw new AdministratorTelegramRateBacklog( 'synthetic shared backlog' ); } } } } namespace App\Services\Ticket { final readonly class ReplyTicketCommand { public function __construct( public int $ticketId, public int $actorId, public string $content, public int $status, public mixed $request, public ?int $ownerId = null, public bool $actorIsAdmin = false, public string $requestKey = '', public ?int $requiredCurrentStatus = null ) {} } final class TicketReplyStateConflict extends \RuntimeException { public function __construct() { parent::__construct('工单已关闭,无法通过 Telegram 回复', 409); } } final class TicketIdempotencyConflict extends \RuntimeException {} final class TicketThreadService { public static array $commands = []; public static array $results = []; public static bool $closed = false; public static bool $fail = false; public function reply(ReplyTicketCommand $command): ?TicketWriteResult { if (self::$fail) { throw new \RuntimeException('synthetic ticket database failure'); } if (self::$closed) { throw new TicketReplyStateConflict(); } self::$commands[] = $command; if (isset(self::$results[$command->requestKey])) { $previous = self::$results[$command->requestKey]; return new TicketWriteResult( $previous->root, $previous->message, $previous->event, $previous->attachments, false ); } $root = new \App\Models\Ticket(); $root->id = $command->ticketId; $root->userid = 7; $root->title = 'Example'; $root->rootid = 0; $root->status = 1; $message = clone $root; $message->id = 900 + count(self::$results); $message->rootid = $root->id; $message->content = $command->content; $result = new TicketWriteResult( $root, $message, '管理员回复工单', [], true ); self::$results[$command->requestKey] = $result; return $result; } } final class TicketNotificationDispatcher { public static array $events = []; public function dispatch(TicketEvent $event): void { self::$events[] = $event; } } } namespace App\Controllers { class BaseController {} class AdminController extends BaseController {} } namespace TelegramBot\Api { final class BotApi { public static array $calls = []; public static bool $fail = false; public static int $nextMessageId = 1000; public function __construct(private string $token) {} public function call($method, $parameters, $timeout) { self::$calls[] = [$method, $parameters, $timeout]; if (self::$fail) { throw new \RuntimeException('synthetic SDK failure with token=' . $this->token); } return $method === 'sendMessage' ? ['message_id' => self::$nextMessageId++] : true; } } } namespace { use App\Models\Configurations; use App\Models\CloudInstance; use App\Models\Ticket; use App\Models\TicketTelegramDelivery; use App\Models\User; use App\Services\Auth; use App\Services\Cloud\CloudSecrets; use App\Services\RedisClient; use App\Services\TicketTelegramConfig; use App\Services\TicketTelegramCredentialCipher; use App\Services\TicketTelegramNotifier; use App\Services\Ticket\TicketEvent; use App\Services\Ticket\TicketNotificationDispatcher; use App\Services\Ticket\TicketTelegramNotificationResult; use App\Services\Ticket\TicketThreadService; use App\Services\Ticket\TicketWriteResult; use App\Controllers\Admin\TelegramController; use App\Controllers\TelegramWebhookController; use TelegramBot\Api\BotApi; final class TelegramTestAbuseStore { public static array $rows = []; public static bool $queryFails = false; } final class TelegramTestConnection { public function transaction($callback) { Configurations::$transactions++; try { return $callback(); } finally { Configurations::$transactions--; } } public function table(string $table): object { if ($table === 'user') { return new TelegramTestUserQuery(); } if ($table === 'ticket') { return new TelegramTestTicketRootQuery(); } if ($table === 'cloud_network_alert_deliveries') { if (TelegramTestAbuseStore::$queryFails) { throw new RuntimeException('synthetic abuse ledger failure'); } return new TelegramTestAbuseQuery(); } throw new RuntimeException('Unexpected table: ' . $table); } public function getSchemaBuilder(): object { return new class { public function hasTable(string $table): bool { return $table === 'cloud_network_alert_deliveries'; } }; } } final class TelegramTestUserQuery { private ?int $id = null; public function where(string $column, mixed $value): self { if ($column === 'id') { $this->id = (int) $value; } return $this; } public function lockForUpdate(): self { if (Configurations::$transactions === 0) { throw new RuntimeException('User lock outside transaction'); } Configurations::$locks++; return $this; } public function first(array $columns = ['*']): ?User { return $this->id === null ? null : (User::$users[$this->id] ?? null); } } final class TelegramTestTicketRootQuery { private array $filters = []; public function where(string $column, mixed $value): self { $this->filters[$column] = $value; return $this; } public function lockForUpdate(): self { if (Configurations::$transactions === 0) { throw new RuntimeException('Ticket lock outside transaction'); } Configurations::$locks++; return $this; } public function first(array $columns = ['*']): ?object { $row = (object) ['id' => 42, 'rootid' => 0]; foreach ($this->filters as $column => $value) { if (($row->{$column} ?? null) != $value) { return null; } } return $row; } } final class TelegramTestAbuseQuery { private array $filters = []; private array $inFilters = []; private array $nullFilters = []; public function where(string $column, mixed $value): self { $this->filters[$column] = $value; return $this; } public function whereIn(string $column, array $values): self { $this->inFilters[$column] = $values; return $this; } public function whereNull(string $column): self { $this->nullFilters[] = $column; return $this; } public function first(): ?object { foreach (TelegramTestAbuseStore::$rows as $row) { foreach ($this->filters as $column => $value) { if (($row->{$column} ?? null) != $value) { continue 2; } } foreach ($this->inFilters as $column => $values) { if (!in_array($row->{$column} ?? null, $values, true)) { continue 2; } } foreach ($this->nullFilters as $column) { if (($row->{$column} ?? null) !== null) { continue 2; } } return $row; } return null; } } final class TelegramTestRedisBackend { public function get($key) { if (RedisClient::$fail) { throw new RuntimeException('Redis unavailable'); } RedisClient::$gets++; return RedisClient::$store[$key] ?? null; } public function setex($key, $ttl, $value) { if (RedisClient::$fail) { throw new RuntimeException('Redis unavailable'); } RedisClient::$sets++; RedisClient::$ttls[$key] = (int) $ttl; RedisClient::$store[$key] = (string) $value; return true; } public function del($key) { if (RedisClient::$fail) { throw new RuntimeException('Redis unavailable'); } RedisClient::$deletes++; unset(RedisClient::$store[$key], RedisClient::$ttls[$key]); return 1; } } final class TelegramTestQuery { public function __construct(private string $name) {} public function lockForUpdate() { if (Configurations::$transactions === 0) { throw new RuntimeException('Row lock requested outside a transaction.'); } Configurations::$locks++; return $this; } public function first() { if ($this->name === 'ticket_telegram_binding' && is_callable(Configurations::$bindingReadHook)) { (Configurations::$bindingReadHook)(); } $row = Configurations::$rows[$this->name] ?? null; return $row === null ? null : clone $row; } public function firstOrFail() { return $this->first() ?? throw new RuntimeException('Missing fixture.'); } public function delete() { unset(Configurations::$rows[$this->name]); } } final class TelegramTestWhereInQuery { public function __construct(private array $names) {} public function get($columns = ['*']) { return array_values(array_filter( Configurations::$rows, fn ($row) => in_array($row->name, $this->names, true) )); } } final class TelegramTestResponse { public int $status = 200; public array $payload = []; public function withJson($payload, $status = 200) { $result = clone $this; $result->status = $status; $result->payload = $payload; return $result; } } final class TelegramTestStream { public int $bytesRequested = 0; public function __construct(private string $body, private bool $knownSize = true) {} public function getSize() { return $this->knownSize ? strlen($this->body) : null; } public function isSeekable() { return true; } public function rewind() {} public function read($bytes) { $this->bytesRequested = $bytes; return substr($this->body, 0, $bytes); } } final class TelegramTestRequest { public function __construct(private string $secret, public TelegramTestStream $stream, private array $payload = []) {} public function getHeaderLine($name) { return $this->secret; } public function getBody() { return $this->stream; } public function getParsedBody() { return $this->payload; } } require dirname(__DIR__) . '/app/Services/Config.php'; require dirname(__DIR__) . '/app/Services/AdminPermission.php'; require dirname(__DIR__) . '/app/Services/TicketTelegramCredentialCipher.php'; require dirname(__DIR__) . '/app/Services/TicketTelegramConfig.php'; require_once dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramDestination.php'; require_once dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramRateLimiter.php'; require dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramTransport.php'; require dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramPreflightException.php'; require dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramLocalUnavailable.php'; require dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramRemoteEffectUnknown.php'; require dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramRateBacklog.php'; require dirname(__DIR__) . '/app/Services/Telegram/TelegramBotApiTransport.php'; require dirname(__DIR__) . '/app/Services/Telegram/AdministratorTelegramChannel.php'; require dirname(__DIR__) . '/app/Services/Ticket/TicketWriteResult.php'; require dirname(__DIR__) . '/app/Services/Ticket/TicketEvent.php'; require dirname(__DIR__) . '/app/Services/Ticket/TicketTelegramNotificationResult.php'; require dirname(__DIR__) . '/app/Services/TicketTelegramNotifier.php'; require dirname(__DIR__) . '/app/Controllers/Admin/TelegramController.php'; require dirname(__DIR__) . '/app/Controllers/TelegramWebhookController.php'; $assert = function ($condition, $message) { if (!$condition) { fwrite(STDERR, $message . PHP_EOL); exit(1); } }; $expectRejected = function ($callback, $message) use ($assert) { $rejected = false; try { $callback(); } catch (Throwable $exception) { $rejected = true; } $assert($rejected, $message); }; $state = function () { return json_decode(Configurations::$rows['ticket_telegram_binding']->value ?? '{}', true); }; $setState = function ($value) { Configurations::$rows['ticket_telegram_binding'] = new Configurations('ticket_telegram_binding', json_encode($value)); }; $configCacheKey = 'ticket_telegram_config_snapshot:v1'; $clearConfigCache = function () use ($configCacheKey) { unset(RedisClient::$store[$configCacheKey], RedisClient::$ttls[$configCacheKey]); }; $update = function ($code, $chatId = '123456') { return ['message' => ['chat' => ['id' => $chatId, 'type' => 'private'], 'from' => ['id' => $chatId, 'is_bot' => false], 'text' => '/start ' . $code]]; }; $ticketEvent = function (string $kind = 'created', int $messageId = 42): TicketEvent { $root = new Ticket(); $root->id = 42; $root->userid = 7; $root->title = 'Example'; $root->content = 'Initial body'; $root->rootid = 0; $root->datetime = 1793604000; $root->status = 1; $root->ticket_type = 'technical'; $root->priority = 'high'; $root->instance_id = 55; $message = clone $root; $message->id = $messageId; $message->content = "Body\nSecond line"; $result = new TicketWriteResult($root, $message, '新工单', [new \stdClass(), new \stdClass()]); return $kind === 'created' ? TicketEvent::created($result) : TicketEvent::userReply($result); }; $ticketReply = function ( int $updateId, string $text = 'Telegram administrator reply', string $chatId = '123456', int $replyToMessageId = 1000 ): array { return [ 'update_id' => $updateId, 'message' => [ 'message_id' => 2000 + $updateId, 'chat' => ['id' => $chatId, 'type' => 'private'], 'from' => ['id' => $chatId, 'is_bot' => false], 'text' => $text, 'reply_to_message' => ['message_id' => $replyToMessageId], ], ]; }; $System_Config = ['enable_telegram' => true, 'telegram_token' => '123456789:' . str_repeat('A', 35), 'telegram_request_token' => 'synthetic-webhook-secret-123', 'super_admin' => '1,2', 'baseUrl' => 'https://example.invalid']; User::$users = [ 1 => new User(1, 1), 2 => new User(2, 0), 3 => new User(3, 1), 7 => new User(7, 0, 1, 'customer', 'owner-secret@example.test', '+15550001111'), ]; CloudInstance::$instances = [55 => new CloudInstance(55, 7, 'vm-support')]; $expectRejected(fn () => TicketTelegramNotifier::createBinding(2), 'Ordinary whitelisted user can issue binding codes.'); $expectRejected(fn () => TicketTelegramNotifier::createBinding(3), 'Non-super administrator can issue binding codes.'); $binding = TicketTelegramNotifier::createBinding(1); $assert((string) Configurations::$rows[TicketTelegramConfig::MIGRATION_MARKER]->value === '1' && !str_contains(Configurations::$rows[TicketTelegramConfig::BOT_TOKEN]->value, $System_Config['telegram_token']) && !str_contains(Configurations::$rows[TicketTelegramConfig::WEBHOOK_SECRET]->value, $System_Config['telegram_request_token']), 'Legacy Telegram settings were not migrated once as encrypted database values.'); TicketTelegramConfig::publicValues(); $cachedSnapshot = json_decode(RedisClient::$store[$configCacheKey] ?? '', true); $assert(is_array($cachedSnapshot) && (RedisClient::$ttls[$configCacheKey] ?? 0) === 60 && str_starts_with($cachedSnapshot[TicketTelegramConfig::BOT_TOKEN] ?? '', 'sbox:telegram:v1:') && str_starts_with($cachedSnapshot[TicketTelegramConfig::WEBHOOK_SECRET] ?? '', 'sbox:telegram:v1:') && !str_contains(RedisClient::$store[$configCacheKey] ?? '', $System_Config['telegram_token']) && !str_contains(RedisClient::$store[$configCacheKey] ?? '', $System_Config['telegram_request_token']), 'Redis snapshot did not contain only encrypted raw Telegram configuration with a 60-second TTL.'); $queriesBeforeCacheHit = Configurations::$queries; $redisGetsBeforeCacheHit = RedisClient::$gets; TicketTelegramConfig::publicValues(); $assert(Configurations::$queries === $queriesBeforeCacheHit && RedisClient::$gets === $redisGetsBeforeCacheHit + 1, 'Warm Telegram configuration cache queried the database or loaded the snapshot more than once.'); $clearConfigCache(); RedisClient::$fail = true; $queriesBeforeFallback = Configurations::$queries; $assert(TicketTelegramConfig::publicValues()['configured'] && Configurations::$queries > $queriesBeforeFallback, 'Redis failure did not fall back to the Telegram configuration database rows.'); RedisClient::$fail = false; TicketTelegramConfig::publicValues(); $expectRejected(fn () => TicketTelegramCredentialCipher::decrypt( Configurations::$rows[TicketTelegramConfig::BOT_TOKEN]->value, 'webhook_secret' ), 'Purpose-separated Telegram ciphertext was accepted as another credential type.'); $assert(preg_match('/^[a-f0-9]{48}$/D', $binding['code']) === 1 && $binding['expires_in'] === 300, 'Binding code entropy/TTL changed.'); $assert($state()['pending_hash'] === hash('sha256', $binding['code']) && !str_contains(Configurations::$rows['ticket_telegram_binding']->value, $binding['code']), 'Plain binding code is persisted.'); $pendingState = $state(); Configurations::$failWrites = true; $expectRejected(fn () => TicketTelegramNotifier::createBinding(1), 'A failed binding-code state write still returned an unusable code.'); Configurations::$failWrites = false; $assert($state() === $pendingState, 'A failed binding-code state write changed the active pending code.'); foreach (['group', 'supergroup', 'channel'] as $type) { $group = $update($binding['code']); $group['message']['chat']['type'] = $type; $assert(!TicketTelegramNotifier::handleUpdate($group), 'A non-private chat consumed the binding code.'); } $forwarded = $update($binding['code']); $forwarded['message']['forward_origin'] = ['type' => 'user']; $assert(!TicketTelegramNotifier::handleUpdate($forwarded), 'Forwarded binding command was accepted.'); $bot = $update($binding['code']); $bot['message']['from']['is_bot'] = true; $assert(!TicketTelegramNotifier::handleUpdate($bot), 'A bot consumed the binding code.'); $mismatched = $update($binding['code']); $mismatched['message']['from']['id'] = '654321'; $assert(!TicketTelegramNotifier::handleUpdate($mismatched), 'Mismatched sender/chat accepted.'); Configurations::$failWrites = true; $expectRejected(fn () => TicketTelegramNotifier::handleUpdate($update($binding['code'])), 'A failed binding state write still reported success.'); Configurations::$failWrites = false; $assert(BotApi::$calls === [], 'A failed binding state write still sent a success confirmation.'); $binding = TicketTelegramNotifier::createBinding(1); $assert(TicketTelegramNotifier::handleUpdate($update($binding['code'])), 'Valid private binding failed.'); $boundState = $state(); $assert(($boundState['bound_admin_id'] ?? 0) === 1 && ($boundState['chat_id'] ?? '') === '123456' && preg_match('/^[a-f0-9]{32}$/D', (string) ($boundState['binding_generation'] ?? '')) === 1, 'Consumed token, recipient or binding generation state is incorrect.'); $assert(count(BotApi::$calls) === 1 && BotApi::$calls[0][0] === 'sendMessage' && BotApi::$calls[0][1]['chat_id'] === '123456' && str_contains(BotApi::$calls[0][1]['text'], '绑定成功'), 'Successful administrator binding did not receive a private confirmation.'); $assert(!TicketTelegramNotifier::handleUpdate($update($binding['code'], '654321')) && $state()['chat_id'] === '123456' && count(BotApi::$calls) === 1, 'Replayed binding token changed the recipient or sent another confirmation.'); $assert(Configurations::$locks >= 3 && Configurations::$transactions === 0, 'Binding issuance/consumption did not use transaction row locks.'); $binding = TicketTelegramNotifier::createBinding(1); $expired = $state(); $expired['pending_expires_at'] = time() - 1; $setState($expired); $assert(!TicketTelegramNotifier::handleUpdate($update($binding['code'])), 'Expired binding token was accepted.'); $binding = TicketTelegramNotifier::createBinding(1); User::$users[1]->is_admin = 0; $assert(!TicketTelegramNotifier::handleUpdate($update($binding['code'])), 'Downgraded issuer completed a binding.'); User::$users[1]->is_admin = 1; $binding = TicketTelegramNotifier::createBinding(1); BotApi::$fail = true; $assert(TicketTelegramNotifier::handleUpdate($update($binding['code'])), 'A failed Telegram confirmation changed a committed binding into a webhook failure.'); BotApi::$fail = false; $failedConfirmationState = $state(); $assert(($failedConfirmationState['bound_admin_id'] ?? 0) === 1 && ($failedConfirmationState['chat_id'] ?? '') === '123456' && preg_match('/^[a-f0-9]{32}$/D', (string) ($failedConfirmationState['binding_generation'] ?? '')) === 1, 'A failed Telegram confirmation rolled back the committed binding.'); $callsAfterFailedConfirmation = count(BotApi::$calls); $assert(!TicketTelegramNotifier::handleUpdate($update($binding['code'])) && count(BotApi::$calls) === $callsAfterFailedConfirmation, 'A replay after a failed confirmation resent or re-consumed the binding code.'); BotApi::$calls = []; BotApi::$nextMessageId = 1000; TicketTelegramDelivery::$rows = []; TicketTelegramDelivery::$nextId = 1; $setState(['bound_admin_id' => 1, 'chat_id' => '123456']); $assert(TicketTelegramNotifier::notify($ticketEvent()) === TicketTelegramNotificationResult::Sent, 'Eligible administrator was not notified.'); $alertText = BotApi::$calls[0][1]['text']; $assert(BotApi::$calls[0][1]['chat_id'] === '123456' && str_starts_with($alertText, '🆕 新工单 #42') && str_contains($alertText, '用户:customer(UID 7)') && str_contains($alertText, '分类:技术支持') && str_contains($alertText, '优先级:高') && str_contains($alertText, '关联实例:vm-support') && str_contains($alertText, '附件:2 个') && str_contains($alertText, '/admin/ticket/42/view') && str_contains($alertText, '直接回复本消息即可回复用户') && !str_contains($alertText, '') && !str_contains($alertText, 'owner-secret@example.test') && !str_contains($alertText, '+15550001111') && !isset(BotApi::$calls[0][1]['parse_mode']), 'Rich alert content or plain-text privacy boundary is wrong.'); $delivery = TicketTelegramDelivery::$rows[1] ?? null; $assert($delivery !== null && $delivery->state === 'sent' && $delivery->telegram_message_id === 1000 && preg_match('/^[a-f0-9]{32}$/D', $delivery->binding_generation) === 1, 'Successful Telegram notification did not persist a reply mapping.'); $assert(TicketTelegramNotifier::notify($ticketEvent()) === TicketTelegramNotificationResult::Sent && count(BotApi::$calls) === 1 && count(TicketTelegramDelivery::$rows) === 1, 'A repeated ticket event was sent or persisted more than once.'); BotApi::$fail = true; $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply', 43)) === TicketTelegramNotificationResult::Failed, 'An uncertain Telegram send was reported as successful.'); BotApi::$fail = false; $uncertain = TicketTelegramDelivery::$rows[2] ?? null; $callsAfterUnknown = count(BotApi::$calls); $assert($uncertain !== null && $uncertain->state === 'unknown' && $uncertain->telegram_message_id === null && TicketTelegramNotifier::notify($ticketEvent('user_reply', 43)) === TicketTelegramNotificationResult::Failed && count(BotApi::$calls) === $callsAfterUnknown, 'An uncertain Telegram delivery was not fenced against replay.'); \App\Services\Telegram\DatabaseAdministratorTelegramRateGate::$mode = 'backlog'; $callsBeforeBacklog = count(BotApi::$calls); $backlogEvent = $ticketEvent('user_reply', 48); $assert(TicketTelegramNotifier::notify($backlogEvent) === TicketTelegramNotificationResult::Failed, 'Shared Telegram backlog was reported as a successful ticket alert.'); $backlogRows = array_values(array_filter( TicketTelegramDelivery::$rows, static fn ($row): bool => $row->ticket_message_id === 48 )); $assert(count($backlogRows) === 1 && $backlogRows[0]->state === 'failed' && $backlogRows[0]->telegram_message_id === null && count(BotApi::$calls) === $callsBeforeBacklog && TicketTelegramNotifier::notify($backlogEvent) === TicketTelegramNotificationResult::Failed && count(BotApi::$calls) === $callsBeforeBacklog, 'Known-no-remote Telegram backlog lost its terminal ticket ledger.'); \App\Services\Telegram\DatabaseAdministratorTelegramRateGate::$mode = 'ready'; // A concurrent rebind after reservation but before the network request is // a known preflight failure: no message was sent and no unknown row remains. $bindingBeforePreflight = $state(); $bindingReads = 0; Configurations::$bindingReadHook = function () use ( &$bindingReads, $setState, $bindingBeforePreflight ): void { $bindingReads++; if ($bindingReads === 2) { $setState([ 'bound_admin_id' => 1, 'chat_id' => '123456', 'binding_generation' => bin2hex(random_bytes(16)), ]); } }; $callsBeforePreflight = count(BotApi::$calls); $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply', 47)) === TicketTelegramNotificationResult::Failed, 'Concurrent rebind preflight was reported as a successful send.'); Configurations::$bindingReadHook = null; $preflightRows = array_filter( TicketTelegramDelivery::$rows, fn ($row) => $row->ticket_message_id === 47 ); $assert(count(BotApi::$calls) === $callsBeforePreflight && $preflightRows === [], 'Preflight failure reached Telegram or was persisted as unknown.'); $setState($bindingBeforePreflight); TicketThreadService::$commands = []; TicketThreadService::$results = []; TicketThreadService::$closed = false; TicketThreadService::$fail = false; TicketNotificationDispatcher::$events = []; $reply = $ticketReply(501); $assert(TicketTelegramNotifier::handleUpdate($reply), 'A reply to a mapped Telegram ticket notification was rejected.'); $replyCommand = TicketThreadService::$commands[0] ?? null; $replyReceipt = BotApi::$calls[count(BotApi::$calls) - 1] ?? null; $assert($replyCommand !== null && $replyCommand->ticketId === 42 && $replyCommand->actorId === 1 && $replyCommand->actorIsAdmin && $replyCommand->requiredCurrentStatus === 1 && $replyCommand->requestKey === 'telegram.' . $delivery->binding_generation . '.update.501' && count(TicketNotificationDispatcher::$events) === 1 && $replyReceipt[0] === 'sendMessage' && str_contains($replyReceipt[1]['text'], '已回复工单 #42'), 'Mapped Telegram reply did not reuse the guarded ticket workflow.'); $receiptCount = count(BotApi::$calls); $dispatchCount = count(TicketNotificationDispatcher::$events); $assert(TicketTelegramNotifier::handleUpdate($reply) && count(TicketNotificationDispatcher::$events) === $dispatchCount && count(BotApi::$calls) === $receiptCount, 'A replayed Telegram update duplicated the reply notification or receipt.'); $abuseRow = static function ( ?int $messageId, string $state = 'sent', ?int $redactedAt = null ) use ($delivery): object { return (object) [ 'binding_generation' => $delivery->binding_generation, 'bound_admin_id' => 1, 'chat_id' => '123456', 'telegram_message_id' => $messageId, 'state' => $state, 'destination_redacted_at' => $redactedAt, ]; }; $commandsBeforeAbuse = count(TicketThreadService::$commands); TelegramTestAbuseStore::$rows = [$abuseRow(3001)]; $assert(TicketTelegramNotifier::handleUpdate( $ticketReply(601, 'must not become ticket reply', '123456', 3001) ) && count(TicketThreadService::$commands) === $commandsBeforeAbuse && str_contains( BotApi::$calls[count(BotApi::$calls) - 1][1]['text'], '网络滥用告警为只读通知' ), 'Sent abuse alert reply reached the ticket workflow.'); TelegramTestAbuseStore::$rows = [$abuseRow(3002, 'unknown')]; $assert(TicketTelegramNotifier::handleUpdate( $ticketReply(602, 'unknown alert reply', '123456', 3002) ) && count(TicketThreadService::$commands) === $commandsBeforeAbuse, 'Unknown abuse alert with a remote message id reached ticket reply.'); TelegramTestAbuseStore::$rows = [$abuseRow(1000)]; $assert(TicketTelegramNotifier::handleUpdate( $ticketReply(603, 'conflicting reply', '123456', 1000) ) && count(TicketThreadService::$commands) === $commandsBeforeAbuse && str_contains( BotApi::$calls[count(BotApi::$calls) - 1][1]['text'], '回复映射存在冲突' ), 'Ticket/abuse reply mapping conflict was not refused.'); TelegramTestAbuseStore::$rows = [ $abuseRow(3003, 'sent', time()), ]; $assert(TicketTelegramNotifier::handleUpdate( $ticketReply(604, 'redacted alert reply', '123456', 3003) ) && count(TicketThreadService::$commands) === $commandsBeforeAbuse && str_contains( BotApi::$calls[count(BotApi::$calls) - 1][1]['text'], '无法识别这条工单通知' ), 'Redacted abuse destination was still treated as a live mapping.'); TelegramTestAbuseStore::$rows = [$abuseRow(null, 'unknown')]; $assert(TicketTelegramNotifier::handleUpdate( $ticketReply(606, 'no-message alert reply', '123456', 3004) ) && count(TicketThreadService::$commands) === $commandsBeforeAbuse && str_contains( BotApi::$calls[count(BotApi::$calls) - 1][1]['text'], '无法识别这条工单通知' ), 'Abuse delivery without a remote message id became replyable.'); TelegramTestAbuseStore::$queryFails = true; $assert(TicketTelegramNotifier::handleUpdate( $ticketReply(605, 'mapping unavailable', '123456', 1000) ) && count(TicketThreadService::$commands) === $commandsBeforeAbuse && str_contains( BotApi::$calls[count(BotApi::$calls) - 1][1]['text'], '暂时无法核对这条通知' ), 'Abuse mapping failure created a ticket reply.'); TelegramTestAbuseStore::$queryFails = false; TelegramTestAbuseStore::$rows = []; $groupReply = $ticketReply(502); $groupReply['message']['chat']['type'] = 'group'; $forwardedReply = $ticketReply(503); $forwardedReply['message']['forward_origin'] = ['type' => 'user']; $wrongChatReply = $ticketReply(504, 'wrong chat', '654321'); foreach ([$groupReply, $forwardedReply, $wrongChatReply] as $unsafeReply) { $assert(!TicketTelegramNotifier::handleUpdate($unsafeReply), 'A group, forwarded or wrong-chat Telegram reply reached the ticket workflow.'); } TicketThreadService::$closed = true; $closedReply = $ticketReply(505); $assert(TicketTelegramNotifier::handleUpdate($closedReply), 'A closed-ticket Telegram reply was not handled terminally.'); $closedReceipt = BotApi::$calls[count(BotApi::$calls) - 1] ?? null; $assert($closedReceipt[0] === 'sendMessage' && str_contains($closedReceipt[1]['text'], '工单已关闭'), 'Closed-ticket Telegram reply did not receive a safe explanation.'); TicketThreadService::$closed = false; BotApi::$fail = true; $dispatchBeforeFailedReceipt = count(TicketNotificationDispatcher::$events); $assert(TicketTelegramNotifier::handleUpdate($ticketReply(506)), 'A failed post-commit Telegram receipt changed a saved ticket reply into failure.'); BotApi::$fail = false; $assert(count(TicketNotificationDispatcher::$events) === $dispatchBeforeFailedReceipt + 1, 'A failed Telegram receipt rolled back or suppressed the committed ticket reply.'); TicketThreadService::$fail = true; $webhookForReplyFailure = new TelegramWebhookController(); $replyFailureRequest = new TelegramTestRequest( TicketTelegramConfig::runtime(true)['webhook_secret'], new TelegramTestStream((string) json_encode($ticketReply(507))) ); $replyFailureResponse = $webhookForReplyFailure->handle( $replyFailureRequest, new TelegramTestResponse(), [] ); TicketThreadService::$fail = false; $assert($replyFailureResponse->status === 503, 'A pre-commit Telegram ticket database failure was acknowledged as success.'); $originalBindingState = $state(); $newGeneration = bin2hex(random_bytes(16)); $setState([ 'bound_admin_id' => 1, 'chat_id' => '123456', 'binding_generation' => $newGeneration, ]); $newBindingDelivery = new TicketTelegramDelivery(); $newBindingDelivery->binding_generation = $newGeneration; $newBindingDelivery->bound_admin_id = 1; $newBindingDelivery->chat_id = '123456'; $newBindingDelivery->ticket_id = 42; $newBindingDelivery->ticket_message_id = 99; $newBindingDelivery->event_kind = 'user_reply'; $newBindingDelivery->telegram_message_id = 1100; $newBindingDelivery->state = 'sent'; $newBindingDelivery->content_hash = str_repeat('a', 64); $newBindingDelivery->created_at = time(); $newBindingDelivery->sent_at = time(); $newBindingDelivery->updated_at = time(); $newBindingDelivery->save(); $commandsBeforeRebind = count(TicketThreadService::$commands); $assert(TicketTelegramNotifier::handleUpdate($ticketReply(508, 'old binding', '123456', 1000)) && count(TicketThreadService::$commands) === $commandsBeforeRebind, 'An old binding generation still authorized its Telegram notification.'); $assert(TicketTelegramNotifier::handleUpdate($ticketReply(501, 'new binding', '123456', 1100)), 'A new binding could not reuse a Telegram update identifier.'); $newBindingCommand = TicketThreadService::$commands[count(TicketThreadService::$commands) - 1] ?? null; $assert($newBindingCommand !== null && $newBindingCommand->requestKey === 'telegram.' . $newGeneration . '.update.501', 'Telegram idempotency did not include the active binding generation.'); $setState($originalBindingState); $commandsBeforeUnsafeReplies = count(TicketThreadService::$commands); $unknownReply = $ticketReply(509, 'unknown notification', '123456', 999999); $viaBotReply = $ticketReply(510); $viaBotReply['message']['via_bot'] = ['id' => 99]; $mediaReply = $ticketReply(511); $mediaReply['message']['photo'] = [['file_id' => 'not-accepted']]; $overflowReply = $ticketReply(512); $overflowReply['update_id'] = (string) PHP_INT_MAX . '0'; $assert(TicketTelegramNotifier::handleUpdate($unknownReply) && !TicketTelegramNotifier::handleUpdate($viaBotReply) && !TicketTelegramNotifier::handleUpdate($mediaReply) && !TicketTelegramNotifier::handleUpdate($overflowReply) && count(TicketThreadService::$commands) === $commandsBeforeUnsafeReplies, 'Unknown, via-bot, media or overflowing Telegram updates reached the ticket workflow.'); User::$users[1]->is_admin = 0; $assert(!TicketTelegramNotifier::handleUpdate($ticketReply(513)), 'A downgraded administrator replied through Telegram.'); User::$users[1]->is_admin = 1; $fallbackEvent = $ticketEvent('user_reply', 44); $fallbackEvent->result->root->userid = 999; $fallbackEvent->result->root->instance_id = 999; $fallbackEvent->result->message->content = str_repeat('测', 5000); $callsBeforeMissingOwner = count(BotApi::$calls); $assert(TicketTelegramNotifier::notify($fallbackEvent) === TicketTelegramNotificationResult::Failed && count(BotApi::$calls) === $callsBeforeMissingOwner, 'A deleted ticket owner received a late Telegram delivery ledger.'); $fallbackEvent->result->root->userid = 7; $assert(TicketTelegramNotifier::notify($fallbackEvent) === TicketTelegramNotificationResult::Sent, 'A missing instance projection suppressed a valid owner notification.'); $fallbackText = BotApi::$calls[count(BotApi::$calls) - 1][1]['text'] ?? ''; $assert(str_contains($fallbackText, 'UID 7') && !str_contains($fallbackText, '关联实例:') && mb_strlen($fallbackText, 'UTF-8') <= 4096, 'Telegram notification fallback or length limit is invalid.'); $closedEvent = $ticketEvent('user_reply', 45); $closedEvent->result->root->status = 0; $assert(TicketTelegramNotifier::notify($closedEvent) === TicketTelegramNotificationResult::Sent, 'Closed ticket update notification was not sent.'); $closedNotification = BotApi::$calls[count(BotApi::$calls) - 1][1]['text'] ?? ''; $assert(str_contains($closedNotification, '工单已关闭,请在管理后台查看') && !str_contains($closedNotification, '直接回复本消息'), 'Closed ticket notification still advertises direct Telegram replies.'); $stale = new TicketTelegramDelivery(); $stale->binding_generation = $originalBindingState['binding_generation']; $stale->bound_admin_id = 1; $stale->chat_id = '123456'; $stale->ticket_id = 42; $stale->ticket_message_id = 46; $stale->event_kind = 'user_reply'; $stale->telegram_message_id = null; $stale->state = 'dispatching'; $stale->content_hash = str_repeat('b', 64); $stale->created_at = time() - 60; $stale->sent_at = null; $stale->updated_at = time() - 60; $stale->save(); $callsBeforeStale = count(BotApi::$calls); $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply', 46)) === TicketTelegramNotificationResult::Failed && $stale->state === 'unknown' && count(BotApi::$calls) === $callsBeforeStale, 'A stale dispatching delivery was replayed or left permanently unresolved.'); $calls = count(BotApi::$calls); foreach ([['bound_admin_id' => 1, 'chat_id' => '-100123456'], ['bound_admin_id' => 2, 'chat_id' => '123456'], ['bound_admin_id' => 1, 'chat_id' => ['unexpected']]] as $unsafe) { $setState($unsafe); $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply')) === TicketTelegramNotificationResult::Skipped, 'Group/ordinary user/malformed recipient was notified.'); } $setState(['bound_admin_id' => 1, 'chat_id' => '123456']); User::$users[1]->is_admin = 0; $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply')) === TicketTelegramNotificationResult::Skipped, 'Downgraded administrator received alerts.'); User::$users[1]->is_admin = 1; User::$users[1]->enable = 0; $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply')) === TicketTelegramNotificationResult::Skipped, 'Disabled administrator received alerts.'); User::$users[1]->enable = 1; $System_Config['super_admin'] = '2'; $assert(TicketTelegramNotifier::notify($ticketEvent('user_reply')) === TicketTelegramNotificationResult::Skipped, 'Removed super-admin received alerts.'); $System_Config['super_admin'] = '1,2'; $assert(count(BotApi::$calls) === $calls, 'Rejected notification still invoked Telegram.'); $controller = new TelegramController(); Auth::$user = User::$users[1]; $secretBeforeAtomicSave = TicketTelegramConfig::runtime(true)['webhook_secret']; $saveRequest = new TelegramTestRequest('', new TelegramTestStream(''), [ 'telegram_enabled' => 'true', 'telegram_webhook_base_url' => 'https://tg.example.invalid/', 'telegram_bot_token' => '', 'telegram_rotate_webhook_secret' => 'true', ]); $deletesBeforeSave = RedisClient::$deletes; $saved = $controller->save($saveRequest, new TelegramTestResponse(), []); $assert($saved->status === 200 && ($saved->payload['ret'] ?? 0) === 1 && ($saved->payload['config']['webhook_url'] ?? '') === 'https://tg.example.invalid/telegram_callback' && !str_contains(json_encode($saved->payload), $System_Config['telegram_token']) && !str_contains(json_encode($saved->payload), $System_Config['telegram_request_token']) && RedisClient::$deletes > $deletesBeforeSave && TicketTelegramConfig::runtime(true)['webhook_secret'] !== $secretBeforeAtomicSave, 'Administrator config save failed or returned Telegram secrets.'); $validTokenCipher = Configurations::$rows[TicketTelegramConfig::BOT_TOKEN]->value; Configurations::$rows[TicketTelegramConfig::BOT_TOKEN]->value = 'corrupt-ciphertext'; $invalidSavedToken = $controller->save(new TelegramTestRequest('', new TelegramTestStream(''), [ 'telegram_enabled' => 'true', 'telegram_webhook_base_url' => 'https://tg.example.invalid', 'telegram_bot_token' => '', ]), new TelegramTestResponse(), []); $assert($invalidSavedToken->status === 422 && ($invalidSavedToken->payload['ret'] ?? 1) === 0, 'Enabled configuration accepted an unreadable stored bot token.'); Configurations::$rows[TicketTelegramConfig::BOT_TOKEN]->value = $validTokenCipher; $setState(['bound_admin_id' => 1, 'chat_id' => '123456']); $replacementToken = '987654321:' . str_repeat('B', 35); $replaced = $controller->save(new TelegramTestRequest('', new TelegramTestStream(''), [ 'telegram_enabled' => 'true', 'telegram_webhook_base_url' => 'https://tg.example.invalid', 'telegram_bot_token' => $replacementToken, ]), new TelegramTestResponse(), []); $assert($replaced->status === 200 && !isset(Configurations::$rows[TicketTelegramConfig::BINDING]) && !str_contains(json_encode($replaced->payload), $replacementToken) && !str_contains(RedisClient::$store[$configCacheKey] ?? '', $replacementToken), 'Replacing the bot token retained the old binding or exposed the new token.'); foreach ([User::$users[2], new User(1, 0), new User(1, 1, 0)] as $account) { Auth::$user = $account; foreach (['save', 'rotateSecret', 'bind', 'unbind', 'webhook'] as $action) { $result = $controller->$action(null, new TelegramTestResponse(), []); $assert($result->status === 403, 'Direct action bypass allows an ordinary/downgraded/disabled account: ' . $action); } } Auth::$user = User::$users[1]; $webhook = new TelegramWebhookController(); $webhookSecret = TicketTelegramConfig::runtime(true)['webhook_secret']; $unauthorized = new TelegramTestRequest('incorrect-secret', new TelegramTestStream('{}')); $assert($webhook->handle($unauthorized, new TelegramTestResponse(), [])->status === 403 && $unauthorized->stream->bytesRequested === 0, 'Webhook secret rejection occurs after processing the body.'); foreach ([true, false] as $knownSize) { $oversized = new TelegramTestRequest($webhookSecret, new TelegramTestStream(str_repeat('x', 65537), $knownSize)); $assert($webhook->handle($oversized, new TelegramTestResponse(), [])->status === 413, 'Oversized webhook body was accepted.'); $assert($oversized->stream->bytesRequested <= 65537, 'Unknown-length webhook body was read without a limit.'); } $badJson = new TelegramTestRequest($webhookSecret, new TelegramTestStream('{broken')); $assert($webhook->handle($badJson, new TelegramTestResponse(), [])->status === 400, 'Malformed webhook JSON accepted.'); Configurations::$rows[TicketTelegramConfig::ENABLED]->value = 'false'; $clearConfigCache(); $disabled = new TelegramTestRequest($webhookSecret, new TelegramTestStream('{}')); $assert($webhook->handle($disabled, new TelegramTestResponse(), [])->status === 403, 'Disabled bot still accepts webhooks.'); Configurations::$rows[TicketTelegramConfig::ENABLED]->value = 'true'; $clearConfigCache(); $assert(TicketTelegramNotifier::registerWebhook(), 'Configured HTTPS webhook registration failed.'); $registration = BotApi::$calls[count(BotApi::$calls) - 1]; $assert($registration[0] === 'setWebhook' && $registration[2] === 10 && $registration[1]['url'] === 'https://tg.example.invalid/telegram_callback' && $registration[1]['secret_token'] === $webhookSecret && $registration[1]['allowed_updates'] === '["message"]', 'Webhook registration lost its secret, timeout or message-only update boundary.'); $expectRejected(fn () => TicketTelegramConfig::save([ 'enabled' => true, 'webhook_base_url' => 'http://example.invalid', ]), 'Non-HTTPS webhook URL accepted.'); TicketTelegramConfig::publicValues(); $preRotationSnapshot = RedisClient::$store[$configCacheKey] ?? ''; $oldSecret = $webhookSecret; $deletesBeforeRotate = RedisClient::$deletes; $rotated = $controller->rotateSecret(null, new TelegramTestResponse(), []); $webhookSecret = TicketTelegramConfig::runtime(true)['webhook_secret']; // Simulate a cache-aside race repopulating the pre-rotation encrypted snapshot. RedisClient::$store[$configCacheKey] = $preRotationSnapshot; RedisClient::$ttls[$configCacheKey] = 60; $queriesBeforeAuthoritativeChecks = Configurations::$queries; $assert($rotated->status === 200 && $oldSecret !== $webhookSecret && RedisClient::$deletes > $deletesBeforeRotate && !TicketTelegramNotifier::authorizeWebhook($oldSecret) && TicketTelegramNotifier::authorizeWebhook($webhookSecret) && Configurations::$queries >= $queriesBeforeAuthoritativeChecks + 2, 'Webhook secret rotation or authoritative runtime reads accepted a stale cached secret.'); BotApi::$fail = true; $failure = ''; try { TicketTelegramNotifier::registerWebhook(); } catch (RuntimeException $exception) { $failure = $exception->getMessage(); } $assert($failure !== '' && !str_contains($failure, TicketTelegramConfig::runtime(true)['bot_token']), 'SDK failure leaked the Telegram bot token.'); BotApi::$fail = false; $clearConfigCache(); Configurations::$failQueries = true; $failure = ''; try { TicketTelegramNotifier::registerWebhook(); } catch (RuntimeException $exception) { $failure = $exception->getMessage(); } Configurations::$failQueries = false; $assert($failure === 'Telegram 配置读取失败,请检查数据库与服务器日志' && !str_contains($failure, 'SQLSTATE'), 'Database error details leaked through webhook registration.'); // Bad legacy values must be consumed once without trapping the administrator in a migration loop. Configurations::$rows = []; $clearConfigCache(); $System_Config['enable_telegram'] = 'true'; $System_Config['telegram_token'] = 'invalid legacy token'; $System_Config['telegram_request_token'] = 'short'; $System_Config['tgUrl'] = 'http://insecure.example.invalid/path'; $legacy = TicketTelegramConfig::publicValues(); $assert((string) Configurations::$rows[TicketTelegramConfig::MIGRATION_MARKER]->value === '1' && !$legacy['bot_token_configured'] && $legacy['webhook_base_url'] === '' && !$legacy['configured'], 'Invalid legacy Telegram values blocked or polluted the one-time migration.'); // A clean installation must not need the payload key until an administrator saves credentials. Configurations::$rows = []; $clearConfigCache(); CloudSecrets::$calls = 0; unset($System_Config['enable_telegram'], $System_Config['telegram_token'], $System_Config['telegram_request_token'], $System_Config['tgUrl']); $fresh = TicketTelegramConfig::publicValues(); $assert(!$fresh['enabled'] && !$fresh['bot_token_configured'] && !$fresh['webhook_secret_configured'] && CloudSecrets::$calls === 0, 'Fresh Telegram configuration unexpectedly required credential decryption.'); $routes = file_get_contents(dirname(__DIR__) . '/config/routes.php'); foreach (['config', 'secret/rotate', 'bind', 'unbind', 'webhook'] as $action) { $matches = array_filter(explode("\n", $routes), fn ($line) => str_contains($line, "'/telegram/" . $action . "'")); $assert(count($matches) === 1 && str_contains(reset($matches), 'new SuperAdmin()'), 'Administrator mutation route lost SuperAdmin/CSRF middleware: ' . $action); } $assert(str_contains($routes, '})->add(new Admin());'), 'Admin group middleware was removed.'); echo "Administrator Telegram private one-time binding, replay/expiry/downgrade and webhook boundaries passed.\n"; }