Files
Febe/tests/Febe.Tests/Web/SettingsApiTests.cs
T

283 lines
17 KiB
C#

using System.Net;
using Febe.Core.Alerts;
using Febe.Core.Engine;
using Febe.Core.Library;
using Febe.Tests.Support;
using Febe.Tests.Web.Part2Support;
using Febe.Tests.Web.Support;
using Febe.Web;
using Febe.Web.Native;
using Microsoft.Extensions.DependencyInjection;
namespace Febe.Tests.Web;
/// <summary>
/// Impostazioni over the API (spec §4.7, §7.5, §8.5, §13.3): naming schemes with their preview and errors, the library
/// folder (desktop only, existing accounts keep their folders), the limits of §7.5 with Italian messages, the
/// notifications (the bot token is never sent back), backups and the rebuild of the database.
/// </summary>
[TestClass]
public sealed class SettingsApiTests
{
[TestMethod]
public async Task GeneralShowsTheSchemesWithPreviewAndRefusesWrongOnes()
{
await using var server = await Part2.StartAsync();
await server.Db.Accounts.AddAsync(Make.Account("marta.prova"));
var general = await server.GetJsonAsync("/api/settings/general");
Assert.AreEqual(NamingScheme.DefaultGeneral, general.Str("namingScheme"));
Assert.AreEqual(NamingScheme.DefaultHighlight, general.Str("highlightScheme"));
Assert.IsTrue(general.Bool("foldersReadOnly"), "Docker: folders change from the container");
Assert.IsTrue(general.Bool("setFileTime"));
Assert.AreEqual(JsonValueKindNull, general.GetProperty("autostart").ValueKind, "the «Avvio» block exists only on Windows");
var preview = general.GetProperty("preview");
Assert.AreEqual("marta.prova", preview.Str("accountFolder"));
Assert.IsTrue(preview.Items("folders").Any(f => f.Items("files").Any(x => x.Str("name").EndsWith("_DBx3kQ2_2.jpg", StringComparison.Ordinal))));
var bad = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/naming-preview", new { namingScheme = "{account}\\{sconosciuto}", highlightScheme = NamingScheme.DefaultHighlight });
Assert.AreEqual(HttpStatusCode.OK, bad.Status);
Assert.IsTrue(bad.Body.Items("errors").Any(e => e.GetString()!.StartsWith("Schema:", StringComparison.Ordinal)));
var (status, error) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/general",
new { namingScheme = "{account}\\{sconosciuto}", highlightScheme = NamingScheme.DefaultHighlight, setFileTime = true });
Assert.AreEqual(HttpStatusCode.BadRequest, status);
StringAssert.StartsWith(error.Str("message"), "Schema:");
const string scheme = @"{account}\{tipo}\{data}_{codice}_{n}";
var (okStatus, saved) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/general", new { namingScheme = scheme, highlightScheme = NamingScheme.DefaultHighlight, setFileTime = false });
Assert.AreEqual(HttpStatusCode.OK, okStatus);
Assert.AreEqual(scheme, saved.Str("namingScheme"));
Assert.IsFalse(saved.Bool("setFileTime"));
var stored = await LibrarySettings.LoadAsync(server.Db.Settings, server.Library.Layout.Root);
Assert.AreEqual(scheme, stored.Naming.General.Text);
Assert.IsFalse(stored.SetFileTimeToPublication);
}
private const System.Text.Json.JsonValueKind JsonValueKindNull = System.Text.Json.JsonValueKind.Null;
[TestMethod]
public async Task TheLibraryFolderChangesOnlyOnTheDesktopAndAccountsKeepTheirFiles()
{
await using (var docker = await Part2.StartAsync())
{
var (status, _) = await docker.SendJsonAsync(HttpMethod.Put, "/api/settings/general",
new { libraryFolder = docker.Temp.Combine("altrove"), namingScheme = NamingScheme.DefaultGeneral, highlightScheme = NamingScheme.DefaultHighlight, setFileTime = true });
Assert.AreEqual(HttpStatusCode.BadRequest, status);
}
await using var server = await Part2.StartAsync(FebeEdition.Desktop);
var withFiles = await server.Db.Accounts.AddAsync(Make.Account("con.file"));
var empty = await server.Db.Accounts.AddAsync(Make.Account("senza.file"));
var oldFolder = server.Library.Layout.AccountFolder(withFiles);
Directory.CreateDirectory(oldFolder);
var newRoot = server.Temp.Combine("nuova-libreria");
var (inside, insideError) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/general",
new { libraryFolder = server.Temp.Combine("dati", "libreria"), namingScheme = NamingScheme.DefaultGeneral, highlightScheme = NamingScheme.DefaultHighlight, setFileTime = true });
Assert.AreEqual(HttpStatusCode.BadRequest, inside);
StringAssert.Contains(insideError.Str("message"), "cartella dei dati");
var (status2, general) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/general",
new { libraryFolder = newRoot, namingScheme = NamingScheme.DefaultGeneral, highlightScheme = NamingScheme.DefaultHighlight, setFileTime = true });
Assert.AreEqual(HttpStatusCode.OK, status2);
Assert.AreEqual(newRoot, general.GetProperty("library").Str("path"));
Assert.AreEqual(newRoot, server.Library.Layout.Root);
Assert.IsTrue(Directory.Exists(newRoot));
var kept = (await server.Db.Accounts.GetAsync(withFiles.Id))!;
Assert.AreEqual(oldFolder, server.Library.Layout.AccountFolder(kept), "an account with files keeps its folder");
var moved = (await server.Db.Accounts.GetAsync(empty.Id))!;
Assert.AreEqual(Path.Combine(newRoot, "senza.file"), server.Library.Layout.AccountFolder(moved), "an account without files goes in the new library");
}
[TestMethod]
public async Task LimitsKeepTheBoundsOfTheSpecWithItalianMessages()
{
await using var server = await Part2.StartAsync();
var limits = await server.GetJsonAsync("/api/settings/limits");
Assert.AreEqual("prudent", limits.Str("profile"));
Assert.AreEqual(3, limits.GetProperty("presets").GetArrayLength());
var rules = limits.GetProperty("rules");
Assert.AreEqual(5, rules.Int("minPauseMinutes"));
Assert.AreEqual(30, rules.Int("maxSessionMinutes"));
Assert.AreEqual(20, rules.Int("maxWindowHours"));
var current = limits.GetProperty("current");
var kinds = current.Items("budgets").Select(b => b.Str("kind")).ToList();
CollectionAssert.AreEqual(new[] { "Home", "ProfileOpen", "StoryView", "BackfillPage", "SinglePost", "FollowingListPage" }, kinds, "every row of the table of §7.5");
CollectionAssert.AreEqual(new[] { "1 ora", "6 ore", "24 ore" }, limits.Items("stops").Select(s => s.GetString()).ToArray());
object Body(Func<Dictionary<string, object?>, Dictionary<string, object?>> edit, string profile = "custom")
{
var values = System.Text.Json.JsonSerializer.Deserialize<Dictionary<string, object?>>(current.GetRawText(), WebTestServer.Json)!;
return new { profile, values = edit(values), pace = "natural", gradualStart = true, activeDays = new[] { 0, 1, 2, 3, 4, 5, 6 } };
}
async Task<string> RefusedAsync(object body)
{
var (status, error) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/limits", body);
Assert.AreEqual(HttpStatusCode.BadRequest, status);
return error.Str("message");
}
StringAssert.Contains(await RefusedAsync(Body(v => { v["sessionMaxMinutes"] = 45; return v; })), "Una sessione non può durare più di 30 minuti");
StringAssert.Contains(await RefusedAsync(Body(v => { v["pauseMinMinutes"] = 3; return v; })), "La pausa minima non può scendere sotto i 5 minuti");
StringAssert.Contains(await RefusedAsync(Body(v => { v["windowStart"] = "02:00"; v["windowEnd"] = "23:30"; return v; })), "20 ore");
StringAssert.Contains(await RefusedAsync(Body(v => { v["windowStart"] = "sette"; return v; })), "07:30");
StringAssert.Contains(await RefusedAsync(new { profile = "prudent", pace = "natural", gradualStart = true, activeDays = Array.Empty<int>() }), "almeno un giorno");
var tooMany = Body(v =>
{
var budgets = System.Text.Json.JsonSerializer.Deserialize<List<Dictionary<string, object?>>>(System.Text.Json.JsonSerializer.Serialize(v["budgets"]), WebTestServer.Json)!;
budgets[1]["perDay"] = 601;
v["budgets"] = budgets;
return v;
});
StringAssert.Contains(await RefusedAsync(tooMany), "doppio di «Rapido»");
var (okStatus, saved) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/limits", Body(v => { v["sessionMaxMinutes"] = 12; v["pauseMinMinutes"] = 25; return v; }));
Assert.AreEqual(HttpStatusCode.OK, okStatus);
Assert.AreEqual("custom", saved.Str("profile"));
var settings = await EngineSettingsStore.LoadAsync(server.Db.Settings);
Assert.AreEqual(Febe.Core.Domain.CautionProfileKind.Custom, settings.ProfileKind);
Assert.AreEqual(TimeSpan.FromMinutes(12), settings.EffectiveProfile.SessionMax);
Assert.AreEqual(TimeSpan.FromMinutes(25), settings.EffectiveProfile.PauseMin);
var (fastStatus, fast) = await server.SendJsonAsync(HttpMethod.Put, "/api/settings/limits", new { profile = "fast", pace = "brisk", gradualStart = false, activeDays = new[] { 1, 2, 3, 4, 5 } });
Assert.AreEqual(HttpStatusCode.OK, fastStatus);
Assert.AreEqual("fast", fast.Str("profile"));
Assert.AreEqual("brisk", fast.Str("pace"));
Assert.IsFalse(fast.Bool("gradualStart"));
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5 }, fast.Items("activeDays").Select(d => d.GetInt32()).ToArray());
Assert.IsNotNull((await EngineSettingsStore.LoadAsync(server.Db.Settings)).Custom, "the «Su misura» values stay stored for later");
}
[TestMethod]
public async Task NotificationsNeverSendTheBotTokenBack()
{
await using var server = await Part2.StartAsync();
var initial = await server.GetJsonAsync("/api/settings/notifications");
Assert.IsTrue(initial.GetProperty("events").Bool("verification"));
Assert.IsFalse(initial.Bool("telegramTokenSet"));
Assert.IsFalse(initial.Bool("windowsAvailable"), "Docker has no Windows notifications");
const string token = "123456789:AAEsegretissimoNonDaMostrare_xyz";
var events = new { verification = true, disconnection = true, throttle = false, backfillDone = true, diskLow = true, unknownFormat = false };
var (status, text) = await server.SendTextAsync(HttpMethod.Put, "/api/settings/notifications",
new { events, windows = false, telegramChatId = "987654", telegramToken = token, removeTelegramToken = false });
Assert.AreEqual(HttpStatusCode.OK, status);
Assert.DoesNotContain(token, text, "the token is not echoed back");
Assert.DoesNotContain("segretissimo", text);
var (_, getText, saved) = await server.GetAsync("/api/settings/notifications");
Assert.DoesNotContain(token, getText);
Assert.IsTrue(saved.Bool("telegramTokenSet"));
Assert.AreEqual("987654", saved.Str("telegramChatId"));
Assert.IsFalse(saved.GetProperty("events").Bool("throttle"));
Assert.AreEqual(token, (await AlertSettingsStore.LoadAsync(server.Db.Settings)).TelegramToken, "stored in the settings of the Data folder");
// An empty token keeps the stored one; «Togli il gettone» removes it.
await server.SendJsonAsync(HttpMethod.Put, "/api/settings/notifications", new { events, windows = false, telegramChatId = "987654", telegramToken = "", removeTelegramToken = false });
Assert.AreEqual(token, (await AlertSettingsStore.LoadAsync(server.Db.Settings)).TelegramToken);
var (testStatus, test) = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/notifications/test", new { channel = "telegram" });
Assert.AreEqual(HttpStatusCode.OK, testStatus);
Assert.IsFalse(test.Bool("sent"), "without a composition nothing leaves (no network in tests and in the demo)");
Assert.AreEqual(NoTelegramSender.Text, test.Str("message"));
var (windowsStatus, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/notifications/test", new { channel = "windows" });
Assert.AreEqual(HttpStatusCode.BadRequest, windowsStatus);
var (badStatus, badText) = await server.SendTextAsync(HttpMethod.Put, "/api/settings/notifications",
new { events, windows = false, telegramChatId = "987654", telegramToken = "con spazi dentro", removeTelegramToken = false });
Assert.AreEqual(HttpStatusCode.BadRequest, badStatus);
Assert.DoesNotContain("con spazi", badText, "a refused token is not echoed either");
await server.SendJsonAsync(HttpMethod.Put, "/api/settings/notifications", new { events, windows = false, telegramChatId = "987654", telegramToken = (string?)null, removeTelegramToken = true });
Assert.IsNull((await AlertSettingsStore.LoadAsync(server.Db.Settings)).TelegramToken);
Assert.IsFalse((await server.GetJsonAsync("/api/settings/notifications")).Bool("telegramTokenSet"));
}
[TestMethod]
public async Task WindowsNotificationsUseTheNativeShell()
{
var shell = new NotifyingShell();
await using var server = await Part2.StartAsync(FebeEdition.Desktop, s => s.AddSingleton<INativeShell>(shell));
Assert.IsTrue((await server.GetJsonAsync("/api/settings/notifications")).Bool("windowsAvailable"));
var (status, result) = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/notifications/test", new { channel = "windows" });
Assert.AreEqual(HttpStatusCode.OK, status);
Assert.IsTrue(result.Bool("sent"));
Assert.AreEqual(1, shell.Notifications);
}
[TestMethod]
public async Task BackupsAndTheRebuildOfTheDatabase()
{
await using var server = await Part2.StartAsync();
var data = await server.GetJsonAsync("/api/settings/data");
Assert.AreEqual(0, data.GetProperty("backups").GetArrayLength());
Assert.AreEqual(7, data.Int("keepDays"));
Assert.IsFalse(data.GetProperty("rebuild").Bool("running"));
var (status, message) = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/backups");
Assert.AreEqual(HttpStatusCode.OK, status);
StringAssert.Contains(message.Str("message"), "febe-2026-10-13.sqlite");
await server.SendJsonAsync(HttpMethod.Post, "/api/settings/backups");
var backups = (await server.GetJsonAsync("/api/settings/data")).Items("backups").ToList();
Assert.HasCount(1, backups, "one copy per day: a new copy replaces today's");
Assert.AreEqual("2026-10-13", backups[0].Str("day"));
var (wrong, wrongError) = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/rebuild", new { confirm = "sì" });
Assert.AreEqual(HttpStatusCode.BadRequest, wrong);
StringAssert.Contains(wrongError.Str("message"), "ricostruisci");
var account = await server.Db.Accounts.AddAsync(Make.Account("giornale.prova"));
var folder = server.Library.Layout.AccountFolder(account);
Part2.WritePhoto(Path.Combine(folder, "post", "foto.jpg"), 3);
var (started, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/settings/rebuild", new { confirm = "Ricostruisci" });
Assert.AreEqual(HttpStatusCode.OK, started);
await Part2.WaitUntilAsync(async () => !(await server.GetJsonAsync("/api/settings/rebuild")).Bool("running"), "rebuild");
var rebuild = await server.GetJsonAsync("/api/settings/rebuild");
Assert.AreEqual(System.Text.Json.JsonValueKind.Null, rebuild.GetProperty("error").ValueKind);
Assert.IsTrue(rebuild.Items("lines").Any(l => l.GetString()!.StartsWith("Cartelle di account lette", StringComparison.Ordinal)));
Assert.IsTrue(File.Exists(Path.Combine(folder, "post", "foto.jpg")), "the rebuild never touches files");
}
[TestMethod]
public async Task AboutSaysVersionShellAndFolders()
{
await using var server = await Part2.StartAsync();
var about = await server.GetJsonAsync("/api/about");
Assert.AreEqual("Docker", about.Str("edition"));
Assert.AreEqual(server.Library.Layout.Root, about.Str("libraryFolder"));
Assert.AreEqual(server.Library.Data.Root, about.Str("dataFolder"));
StringAssert.Contains(about.Str("guide"), "/wiki");
}
private sealed class NotifyingShell : INativeShell
{
public int Notifications { get; private set; }
public bool CanPickFolder => false;
public bool CanShowInFolder => false;
public bool CanOpenUrl => false;
public bool CanNotify => true;
public bool SupportsAutostart => true;
public Task<string?> PickFolderAsync(string title, string? initialFolder, CancellationToken ct) => Task.FromResult<string?>(null);
public Task<bool> ShowInFolderAsync(string fullPath, CancellationToken ct) => Task.FromResult(false);
public Task<bool> OpenUrlAsync(Uri address, CancellationToken ct) => Task.FromResult(false);
public Task NotifyAsync(string title, string message, CancellationToken ct)
{
Notifications++;
return Task.CompletedTask;
}
public Task<bool> GetAutostartAsync(CancellationToken ct) => Task.FromResult(false);
public Task SetAutostartAsync(bool enabled, CancellationToken ct) => Task.CompletedTask;
}
}