Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
283 lines
17 KiB
C#
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;
|
|
}
|
|
}
|