using System.Collections.Concurrent; using System.Net; using System.Text; using System.Text.Json; using Anubis.Core; using Anubis.Notifications; using Anubis.Server; using Microsoft.Extensions.Logging.Abstractions; namespace Anubis.Tests; /// Telegram and the sign of life (issue #52, SPEC 14), against a fake Telegram server. [TestClass] public sealed class TelegramTests { private const string Token = "123456:fake-token-for-tests_abcdefghijklmnop"; private const string Chat = "424242"; private static readonly CancellationToken _none = CancellationToken.None; [TestMethod] [TestCategory(Category.Unit)] public async Task EveryMessageHasItsStateAndAFailureIsTriedAgainLater() { await using var rig = await TradingRig.CreateAsync().ConfigureAwait(false); var telegram = new FakeTelegram(); TelegramSettings? configured = null; using var http = new HttpClient(telegram); var sender = new NotificationSender(rig.Db, rig.Clock, _ => Task.FromResult(configured), token => new TelegramClient(http, token)); await EnqueueAsync(rig, "uno", "due").ConfigureAwait(false); // Without Telegram the messages wait in the queue: never "sent". Assert.AreEqual(0, await sender.SendDueAsync(_none).ConfigureAwait(false)); Assert.AreEqual(new NotificationSummary(null, 2, 0, 0, null), await sender.SummaryAsync(_none).ConfigureAwait(false)); // Telegram slows us down: the first fails, the second waits for the next pass. configured = new TelegramSettings(Token, Chat); telegram.Refuse = "sendMessage"; telegram.RefusalStatus = HttpStatusCode.TooManyRequests; Assert.AreEqual(0, await sender.SendDueAsync(_none).ConfigureAwait(false)); var states = await StatesAsync(rig).ConfigureAwait(false); Assert.AreEqual("failed/1/Telegram ha risposto 429: Too Many Requests: retry after 90", states["uno"].Text); Assert.AreEqual(rig.Clock.UtcNow.AddSeconds(90), states["uno"].Next, "Telegram's own wait, longer than the first pause of a minute."); Assert.AreEqual("pending/0/", states["due"].Text); // Back up: what is due leaves, the failed one when its time comes. telegram.Refuse = null; Assert.AreEqual(1, await sender.SendDueAsync(_none).ConfigureAwait(false)); rig.Clock.Advance(TimeSpan.FromSeconds(90)); Assert.AreEqual(1, await sender.SendDueAsync(_none).ConfigureAwait(false)); states = await StatesAsync(rig).ConfigureAwait(false); Assert.AreEqual(("sent/2/", "sent/1/"), (states["uno"].Text, states["due"].Text)); Assert.AreEqual(2, telegram.Sent.Count(m => m.Chat == Chat)); Assert.AreEqual(new NotificationSummary(rig.Clock.UtcNow, 0, 0, 0, null), await sender.SummaryAsync(_none).ConfigureAwait(false)); } [TestMethod] [TestCategory(Category.Unit)] public async Task ARefusalIsNotTriedAgainAndAMessageOlderThanADayIsGivenUp() { await using var rig = await TradingRig.CreateAsync().ConfigureAwait(false); var telegram = new FakeTelegram { Refuse = "sendMessage", RefusalStatus = HttpStatusCode.BadRequest }; using var http = new HttpClient(telegram); var sender = new NotificationSender(rig.Db, rig.Clock, _ => Task.FromResult(new TelegramSettings(Token, Chat)), token => new TelegramClient(http, token)); await EnqueueAsync(rig, "rifiutato").ConfigureAwait(false); await sender.SendDueAsync(_none).ConfigureAwait(false); var states = await StatesAsync(rig).ConfigureAwait(false); Assert.AreEqual("failed/1/Telegram ha risposto 400: Bad Request: chat not found", states["rifiutato"].Text); Assert.IsNull(states["rifiutato"].Next, "A refusal is final: the same message would be refused again."); telegram.Refuse = null; await EnqueueAsync(rig, "vecchio").ConfigureAwait(false); rig.Clock.Advance(TimeSpan.FromHours(25)); Assert.AreEqual(0, await sender.SendDueAsync(_none).ConfigureAwait(false)); states = await StatesAsync(rig).ConfigureAwait(false); Assert.AreEqual("failed/0/Non partito entro un giorno: non lo mando più.", states["vecchio"].Text); Assert.IsEmpty(telegram.Sent); var summary = await sender.SummaryAsync(_none).ConfigureAwait(false); Assert.AreEqual((0, 0, 2), (summary.Pending, summary.Retrying, summary.GaveUp)); // The pauses between attempts grow up to an hour. Assert.AreEqual("1 2 4 8 16 32 60 60", string.Join(" ", Enumerable.Range(1, 8).Select(a => NotificationSender.Pause(a).TotalMinutes))); } [TestMethod] [TestCategory(Category.Unit)] public async Task FermaWantsAConfirmationWithinTwoMinutes() { var clock = new ManualClock(new DateTimeOffset(2026, 11, 11, 9, 0, 0, TimeSpan.Zero)); var desk = new FakeDesk(); var commands = new TelegramCommands(desk, clock); Assert.Contains("/conferma entro 2 minuti", (await commands.AnswerAsync("/ferma", _none).ConfigureAwait(false))!); Assert.AreEqual(0, desk.Stops); clock.Advance(TimeSpan.FromSeconds(100)); Assert.AreEqual("fermato", await commands.AnswerAsync("/conferma", _none).ConfigureAwait(false)); Assert.AreEqual(1, desk.Stops); // Too late, or another command in between: nothing to confirm. await commands.AnswerAsync("/ferma", _none).ConfigureAwait(false); clock.Advance(TimeSpan.FromMinutes(3)); Assert.Contains("niente da confermare", (await commands.AnswerAsync("/conferma", _none).ConfigureAwait(false))!); await commands.AnswerAsync("/ferma", _none).ConfigureAwait(false); await commands.AnswerAsync("/stato", _none).ConfigureAwait(false); Assert.Contains("niente da confermare", (await commands.AnswerAsync("/conferma", _none).ConfigureAwait(false))!); Assert.AreEqual(1, desk.Stops); // The other commands, the bot's name of a group, help, and plain text that is no command. Assert.AreEqual("stato", await commands.AnswerAsync("/stato@AnubisBot", _none).ConfigureAwait(false)); Assert.AreEqual("posizioni", await commands.AnswerAsync("/POSIZIONI", _none).ConfigureAwait(false)); Assert.AreEqual("oggi", await commands.AnswerAsync(" /oggi grazie", _none).ConfigureAwait(false)); Assert.AreEqual("pausa", await commands.AnswerAsync("/pausa", _none).ConfigureAwait(false)); Assert.AreEqual("riprendi", await commands.AnswerAsync("/riprendi", _none).ConfigureAwait(false)); Assert.AreEqual(TelegramCommands.Help, await commands.AnswerAsync("/aiuto", _none).ConfigureAwait(false)); Assert.StartsWith("Non conosco questo comando.", (await commands.AnswerAsync("/compra BTC", _none).ConfigureAwait(false))!); Assert.IsNull(await commands.AnswerAsync("ciao", _none).ConfigureAwait(false)); Assert.DoesNotContain("limiti", TelegramCommands.Help.Split('\n')[0]); } [TestMethod] [TestCategory(Category.Unit)] public async Task OnlyTheChatOfTheSettingsIsObeyedAndOldMessagesAreNot() { var clock = new ManualClock(new DateTimeOffset(2026, 11, 11, 9, 0, 0, TimeSpan.Zero)); var telegram = new FakeTelegram(); using var http = new HttpClient(telegram); var desk = new FakeDesk(); var bot = new TelegramBot(clock, _ => Task.FromResult(new TelegramSettings(Token, Chat)), token => new TelegramClient(http, token), new TelegramCommands(desk, clock), NullLogger.Instance); telegram.Write("999", "/pausa", clock.UtcNow); telegram.Write(Chat, "/pausa", clock.UtcNow - TimeSpan.FromHours(20)); telegram.Write(Chat, "/stato", clock.UtcNow); Assert.AreEqual(1, await bot.PollOnceAsync(_none).ConfigureAwait(false)); Assert.AreEqual((Chat, "stato"), telegram.Sent.Single()); Assert.AreEqual(0, desk.Pauses, "Neither the stranger's /pausa nor yesterday's."); // The next read tells Telegram the first three were read. Assert.AreEqual(0, await bot.PollOnceAsync(_none).ConfigureAwait(false)); Assert.AreEqual(4, telegram.LastOffset); // Without Telegram configured the loop only waits. var idle = new TelegramBot(clock, _ => Task.FromResult(null), token => new TelegramClient(http, token), new TelegramCommands(desk, clock), NullLogger.Instance); Assert.AreEqual(-1, await idle.PollOnceAsync(_none).ConfigureAwait(false)); } [TestMethod] [TestCategory(Category.Unit)] public async Task TheSignOfLifeCallsTheServiceAndSaysWhenItFails() { var clock = new ManualClock(new DateTimeOffset(2026, 11, 11, 9, 0, 0, TimeSpan.Zero)); var calls = 0; var fake = new FakeHttp().On(u => u.Host == "hc.example", _ => FakeHttp.Respond("OK", ++calls == 2 ? HttpStatusCode.ServiceUnavailable : HttpStatusCode.OK)); using var http = fake.Client(); Uri? address = null; var beat = new Heartbeat(http, clock, _ => Task.FromResult(address), NullLogger.Instance); Assert.IsFalse(await beat.BeatAsync(_none).ConfigureAwait(false), "No address, no call."); Assert.IsEmpty(fake.Requests); address = new Uri("https://hc.example/ping/abc"); Assert.IsTrue(await beat.BeatAsync(_none).ConfigureAwait(false)); Assert.AreEqual(clock.UtcNow, beat.LastOk); clock.Advance(TimeSpan.FromMinutes(1)); Assert.IsFalse(await beat.BeatAsync(_none).ConfigureAwait(false)); Assert.AreEqual(("Il servizio ha risposto 503.", clock.UtcNow - TimeSpan.FromMinutes(1)), (beat.LastError, beat.LastOk)); Assert.IsNull(Heartbeat.Check("https://hc-ping.com/uuid")); Assert.IsNull(Heartbeat.Check("http://192.168.30.23:8000/ping/x")); Assert.IsNotNull(Heartbeat.Check("http://hc-ping.com/uuid")); Assert.IsNotNull(Heartbeat.Check("http://8.8.8.8/ping/x"), "A public address in plain http travels in clear."); Assert.IsNull(Heartbeat.Check("http://10.0.0.5/ping/x")); Assert.IsNull(Heartbeat.Check("http://[fd00::5]/ping/x")); Assert.IsNotNull(Heartbeat.Check("ftp://example.com")); Assert.IsNotNull(Heartbeat.Check("non è un indirizzo")); } /// /// The acceptance criterion of SPEC 14 with the real server: commands from the phone change the bot's state, the /// changes reach the phone, a stranger is ignored, and after "Ferma tutto" the phone cannot restart the bot. /// [TestMethod] [TestCategory(Category.Integration)] public async Task TheCommandsWorkFromThePhoneThroughTheRealServer() { var telegram = new FakeTelegram(); var env = ServerHarness.DockerSqlite(); env["TELEGRAM_BOT_TOKEN"] = Token; env["TELEGRAM_CHAT_ID"] = Chat; await using var server = await ServerHarness.StartAsync("docker", env, telegramHttp: telegram).ConfigureAwait(false); var services = server.Host.Services!; async Task AskAsync(string text, string chat = Chat) { var before = telegram.Sent.Count; telegram.Write(chat, text, DateTimeOffset.UtcNow); var until = DateTimeOffset.UtcNow.AddSeconds(20); while (DateTimeOffset.UtcNow < until) { if (telegram.Sent.Skip(before).FirstOrDefault(m => m.Chat == chat && !m.Text.Contains("(da Telegram)", StringComparison.Ordinal)) is { Text: { } answer }) { return answer; } await Task.Delay(50).ConfigureAwait(false); } return "(nessuna risposta)"; } async Task StateAsync() => (await services.Settings.GetAsync(SettingsStore.BotState.Key, _none).ConfigureAwait(false)).Value; Assert.StartsWith("Bot attivo", await AskAsync("/stato").ConfigureAwait(false)); Assert.AreEqual("Nessuna posizione aperta.", await AskAsync("/posizioni").ConfigureAwait(false)); Assert.AreEqual("Nessun ordine oggi.", await AskAsync("/oggi").ConfigureAwait(false)); Assert.StartsWith("In pausa", await AskAsync("/pausa").ConfigureAwait(false)); Assert.AreEqual("paused", await StateAsync().ConfigureAwait(false)); await WaitForAsync(() => telegram.Sent.Any(m => m.Text.StartsWith("Bot in pausa (da Telegram)", StringComparison.Ordinal))).ConfigureAwait(false); Assert.AreEqual("(nessuna risposta)", await AskAsync("/riprendi", "777").ConfigureAwait(false), "Another chat gets nothing."); Assert.AreEqual("paused", await StateAsync().ConfigureAwait(false)); Assert.AreEqual("Ripartito dalla pausa.", await AskAsync("/riprendi").ConfigureAwait(false)); Assert.AreEqual("active", await StateAsync().ConfigureAwait(false)); Assert.Contains("/conferma", await AskAsync("/ferma").ConfigureAwait(false)); Assert.AreEqual("active", await StateAsync().ConfigureAwait(false)); Assert.StartsWith("«Ferma tutto» fatto", await AskAsync("/conferma").ConfigureAwait(false)); Assert.AreEqual("stopped", await StateAsync().ConfigureAwait(false)); Assert.Contains("riattivalo dalla pagina Rischio", await AskAsync("/riprendi").ConfigureAwait(false)); Assert.AreEqual("stopped", await StateAsync().ConfigureAwait(false)); // Every notice has its state, and the Impostazioni page shows the last message that left. await WaitForAsync(() => telegram.Sent.Any(m => m.Text.StartsWith("«Ferma tutto» (da Telegram)", StringComparison.Ordinal))).ConfigureAwait(false); var notices = await services.Db.ReadAsync(s => s.QueryAsync("SELECT kind, status FROM notifications", r => r.Text("kind") + "/" + r.Text("status")), _none) .ConfigureAwait(false); Assert.Contains("bot_paused/sent", notices); Assert.Contains("bot_active/sent", notices); Assert.IsFalse(telegram.Sent.Any(m => m.Text.Contains(Token, StringComparison.Ordinal))); await server.SignInFirstTimeAsync().ConfigureAwait(false); var page = await server.TextAsync("/impostazioni").ConfigureAwait(false); Assert.Contains("Telegram e segnale di vita", page); Assert.Contains("Token e chat arrivano dalle variabili", page); Assert.DoesNotContain(Token, page); } private static async Task WaitForAsync(Func condition) { var until = DateTimeOffset.UtcNow.AddSeconds(20); while (!condition()) { Assert.IsLessThan(until, DateTimeOffset.UtcNow, "Timed out."); await Task.Delay(50).ConfigureAwait(false); } } private static Task EnqueueAsync(TradingRig rig, params string[] messages) => rig.Db.WriteAsync(async s => { foreach (var message in messages) { await NotificationSender.EnqueueAsync(s, rig.Clock, "test", message, _none).ConfigureAwait(false); rig.Clock.Advance(TimeSpan.FromMilliseconds(1)); } }, _none); private static async Task> StatesAsync(TradingRig rig) => (await rig.QueryAsync("SELECT message, status, attempts, last_error, next_attempt_at FROM notifications", r => (Message: r.Text("message"), Text: r.Text("status") + "/" + r.Number("attempts") + "/" + r.TextOrNull("last_error"), Next: r.MomentOrNull("next_attempt_at"))) .ConfigureAwait(false)).ToDictionary(x => x.Message, x => (x.Text, x.Next)); private sealed class FakeDesk : ITelegramDesk { public int Stops { get; private set; } public int Pauses { get; private set; } public Task StatusAsync(CancellationToken cancellationToken) => Task.FromResult("stato"); public Task PositionsAsync(CancellationToken cancellationToken) => Task.FromResult("posizioni"); public Task TodayAsync(CancellationToken cancellationToken) => Task.FromResult("oggi"); public Task PauseAsync(CancellationToken cancellationToken) { Pauses++; return Task.FromResult("pausa"); } public Task ResumeAsync(CancellationToken cancellationToken) => Task.FromResult("riprendi"); public Task StopAllAsync(CancellationToken cancellationToken) { Stops++; return Task.FromResult("fermato"); } } } /// /// A Telegram Bot API on the test's side: messages written by the test come back from getUpdates, sendMessage is /// recorded, and one method can be made to refuse. getUpdates answers at once (no long wait) after a short pause. /// internal sealed class FakeTelegram : HttpMessageHandler { private readonly ConcurrentQueue<(long Id, string Chat, string Text, DateTimeOffset Date)> _updates = new(); private long _nextId = 1; public List<(string Chat, string Text)> Sent { get; } = []; public long LastOffset { get; private set; } /// The method that fails, with . public string? Refuse { get; set; } public HttpStatusCode RefusalStatus { get; set; } = HttpStatusCode.BadRequest; public void Write(string chat, string text, DateTimeOffset at) => _updates.Enqueue((Interlocked.Increment(ref _nextId) - 1, chat, text, at)); protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var method = request.RequestUri!.AbsolutePath.Split('/')[^1]; using var body = JsonDocument.Parse(request.Content is null ? "{}" : await request.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false)); if (method == Refuse) { return RefusalStatus == HttpStatusCode.TooManyRequests ? Json(RefusalStatus, """{"ok":false,"error_code":429,"description":"Too Many Requests: retry after 90","parameters":{"retry_after":90}}""") : Json(RefusalStatus, """{"ok":false,"error_code":400,"description":"Bad Request: chat not found"}"""); } switch (method) { case "getMe": return Json(HttpStatusCode.OK, """{"ok":true,"result":{"id":1,"is_bot":true,"username":"AnubisProvaBot"}}"""); case "sendMessage": lock (Sent) { Sent.Add((body.RootElement.GetProperty("chat_id").GetString()!, body.RootElement.GetProperty("text").GetString()!)); } return Json(HttpStatusCode.OK, """{"ok":true,"result":{"message_id":1}}"""); case "getUpdates": var offset = body.RootElement.TryGetProperty("offset", out var o) ? o.GetInt64() : 0; LastOffset = offset; while (_updates.TryPeek(out var first) && first.Id < offset) { _updates.TryDequeue(out _); } if (_updates.IsEmpty) { await Task.Delay(30, cancellationToken).ConfigureAwait(false); } var items = _updates.ToArray().Where(u => u.Id >= offset).Select(u => new { update_id = u.Id, message = new { message_id = u.Id, date = u.Date.ToUnixTimeSeconds(), chat = new { id = long.Parse(u.Chat, System.Globalization.CultureInfo.InvariantCulture) }, text = u.Text }, }); return Json(HttpStatusCode.OK, JsonSerializer.Serialize(new { ok = true, result = items })); default: return Json(HttpStatusCode.NotFound, """{"ok":false,"description":"Not Found"}"""); } } private static HttpResponseMessage Json(HttpStatusCode status, string json) => new(status) { Content = new StringContent(json, Encoding.UTF8, "application/json") }; }