Files
Febe/tests/Febe.Tests/Alerts/Support/AlertBed.cs
T

118 lines
4.6 KiB
C#

using Febe.Core.Abstractions;
using Febe.Core.Alerts;
using Febe.Core.Domain;
using Febe.Core.Engine;
using Febe.Core.Storage;
using Febe.Tests.Engine.Support;
using Febe.Web.Native;
namespace Febe.Tests.Alerts.Support;
/// <summary>
/// The engine's services on a temporary database and a virtual clock (<see cref="EngineTestBed"/>), with an
/// <see cref="AlertService"/> listening to them: a fake desktop shell, a fake Telegram, a fake free-space probe on two
/// folders. Telegram and Windows notifications are switched on unless asked otherwise.
/// </summary>
internal sealed class AlertBed : IAsyncDisposable
{
public const string Token = "4839574812:AAF-tokendiprova_SegretoDaNonMostrare";
public const string Chat = "-100123456";
public const string LibraryFolder = "/prova/libreria";
public const string DataFolder = "/prova/dati";
private AlertBed(EngineTestBed engine, AlertService alerts, FakeNativeShell shell, FakeTelegramHandler telegram, FakeFreeSpaceProbe disk, AlertLogRecorder log, TelegramClient client)
{
Engine = engine;
Alerts = alerts;
Shell = shell;
Telegram = telegram;
Disk = disk;
Log = log;
Client = client;
}
public EngineTestBed Engine { get; }
public AlertService Alerts { get; }
public FakeNativeShell Shell { get; }
public FakeTelegramHandler Telegram { get; }
public FakeFreeSpaceProbe Disk { get; }
public AlertLogRecorder Log { get; }
public TelegramClient Client { get; }
public List<AlertOutcome> Outcomes { get; } = [];
public static async Task<AlertBed> CreateAsync(bool telegram = true, bool windows = true, AlertEvents? events = null, TimeSpan? telegramTimeout = null, DateTimeOffset? start = null)
{
var engine = await EngineTestBed.CreateAsync(start);
await AlertSettingsStore.SaveAsync(engine.Db.Settings, new AlertSettings(events ?? AlertEvents.All, windows, telegram ? Chat : null, telegram ? Token : null));
var shell = new FakeNativeShell();
var handler = new FakeTelegramHandler();
var disk = new FakeFreeSpaceProbe();
var log = new AlertLogRecorder();
var client = new TelegramClient(handler, telegramTimeout);
var alerts = new AlertService(
engine.Db.Settings,
engine.Clock,
engine.Services.Events,
[new NativeShellAlertChannel(shell), new TelegramAlertChannel(client)],
new AlertServiceOptions
{
Folders = [WatchedFolder.Library(LibraryFolder), WatchedFolder.Data(DataFolder)],
FreeSpace = disk,
Log = log.Write,
}).Attach();
var bed = new AlertBed(engine, alerts, shell, handler, disk, log, client);
alerts.Handled += (_, outcome) =>
{
lock (bed.Outcomes)
{
bed.Outcomes.Add(outcome);
}
};
return bed;
}
/// <summary>Reports a signal through the circuit breaker and waits for its incident, its event and its alert.</summary>
public async Task ReportAsync(SignalLevel level, string code = "segnale-prova")
{
await Engine.Breaker.ReportAsync(new Signal(level, code, "https://sito.prova/x", Engine.Clock.Now));
await Engine.Breaker.FlushAsync();
await Alerts.FlushAsync();
}
/// <summary>Writes a timeline event as the engine does and waits for its alert.</summary>
public async Task WriteEventAsync(EventSeverity severity, string code, string message, long? accountId = null)
{
await Engine.Services.Events.WriteAsync(severity, code, message, accountId);
await Alerts.FlushAsync();
}
/// <summary>Everything the bed recorded that leaves Febe or stays on disk: log lines, events, alert texts.</summary>
public async Task<string> EverythingWrittenAsync()
{
var events = await Engine.Db.Events.ListAsync(new EventQuery { Limit = 1000 });
var settings = await Engine.Db.Settings.GetAllAsync();
return string.Join(
"\n",
new[] { Log.All }
.Concat(events.Select(e => e.Code + " " + e.Message))
.Concat(Shell.Notifications.Select(n => n.Title + " " + n.Message))
.Concat(Telegram.Requests.Select(r => r.Body))
.Concat(Outcomes.SelectMany(o => o.Deliveries.Select(d => d.Delivery.Problem ?? string.Empty)))
.Concat(settings.Where(s => s.Key != AlertSettingKeys.TelegramToken).Select(s => s.Key + "=" + s.Value)));
}
public async ValueTask DisposeAsync()
{
Alerts.Dispose();
Client.Dispose();
await Engine.DisposeAsync();
}
}