ci / test (postgres) (push) Successful in 2m23s
ci / test (sqlite) (push) Successful in 2m5s
ci / image (push) Successful in 30s
ci / test (postgres) (pull_request) Successful in 2m14s
ci / test (sqlite) (pull_request) Successful in 1m58s
ci / image (pull_request) Successful in 9s
The user allowed the download, so the interface now uses the typeface of the mockups instead of the system one. The variable file (weights 400-700) and its SIL OFL licence are embedded and served by the app itself, never fetched from the internet; source and SHA-256 are in API-NOTES. The typeface is slightly wider, so top-bar labels and buttons move to 13 px as in the mockup, keeping the date line whole at 1440 px. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
463 lines
22 KiB
C#
463 lines
22 KiB
C#
using System.Net;
|
|
using System.Net.Http.Json;
|
|
using System.Net.WebSockets;
|
|
using System.Text;
|
|
using Anubis.Core;
|
|
using Anubis.Db;
|
|
using Anubis.Demo;
|
|
using Anubis.Platform;
|
|
using Anubis.Server;
|
|
|
|
namespace Anubis.Tests;
|
|
|
|
[TestClass]
|
|
[TestCategory(Category.Integration)]
|
|
public sealed class ServerTests
|
|
{
|
|
[TestMethod]
|
|
public async Task SignInFirstAccessAndApi()
|
|
{
|
|
var (env, postgres) = await ServerHarness.DockerOnEngineAsync();
|
|
await using var engine = postgres;
|
|
await using var server = await ServerHarness.StartAsync("docker", env);
|
|
|
|
// A return address that leaves the site never reaches the form.
|
|
StringAssert.Contains(await server.TextAsync("/accesso?ritorno=%2F%09%2Fevil.example"), "name=\"ritorno\" value=\"/\"");
|
|
|
|
// Without a session: pages go to sign-in, the API answers 401.
|
|
using (var page = await server.GetAsync("/"))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.Redirect, page.StatusCode);
|
|
StringAssert.StartsWith(ServerHarness.Location(page), "/accesso");
|
|
}
|
|
|
|
using (var api = await server.GetAsync("/api/status"))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.Unauthorized, api.StatusCode);
|
|
}
|
|
|
|
// Wrong password: back to the form with the reason.
|
|
using (var wrong = await server.PostFormAsync("/accesso", "/azioni/accesso", ("password", "not-the-password")))
|
|
{
|
|
StringAssert.Contains(ServerHarness.Location(wrong), "errore=password");
|
|
}
|
|
|
|
// A form without the CSRF field is refused.
|
|
using (var noCsrf = await server.Http.PostAsync(new Uri("/azioni/accesso", UriKind.Relative),
|
|
new FormUrlEncodedContent([new("password", ServerHarness.AdminPassword)])))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.BadRequest, noCsrf.StatusCode);
|
|
}
|
|
|
|
// The initial password lets in only to change it.
|
|
using (var login = await server.PostFormAsync("/accesso", "/azioni/accesso", ("password", ServerHarness.AdminPassword)))
|
|
{
|
|
Assert.AreEqual("/", ServerHarness.Location(login));
|
|
var cookie = login.Headers.GetValues("Set-Cookie").Single(c => c.StartsWith("anubis_session=", StringComparison.Ordinal));
|
|
StringAssert.Contains(cookie, "httponly");
|
|
StringAssert.Contains(cookie, "samesite=strict");
|
|
}
|
|
|
|
using (var forced = await server.GetAsync("/"))
|
|
{
|
|
Assert.AreEqual("/primo-accesso", ServerHarness.Location(forced));
|
|
}
|
|
|
|
using (var same = await server.PostFormAsync("/primo-accesso", "/azioni/primo-accesso",
|
|
("attuale", ServerHarness.AdminPassword), ("nuova", ServerHarness.AdminPassword), ("conferma", ServerHarness.AdminPassword)))
|
|
{
|
|
StringAssert.Contains(ServerHarness.Location(same), "errore=uguale");
|
|
}
|
|
|
|
const string chosen = "chosen-test-pass-2";
|
|
using (var change = await server.PostFormAsync("/primo-accesso", "/azioni/primo-accesso",
|
|
("attuale", ServerHarness.AdminPassword), ("nuova", chosen), ("conferma", chosen)))
|
|
{
|
|
Assert.AreEqual("/?ok=password", ServerHarness.Location(change));
|
|
}
|
|
|
|
var home = await server.TextAsync("/");
|
|
StringAssert.Contains(home, "Panoramica");
|
|
StringAssert.Contains(home, "Simulazione: nessun soldo reale");
|
|
StringAssert.Contains(home, "Ancora nessun risultato", "Production never shows invented numbers.");
|
|
|
|
// API: reading works, writing needs the CSRF header.
|
|
var status = await server.Http.GetFromJsonAsync<Dictionary<string, object>>(new Uri("/api/status", UriKind.Relative));
|
|
Assert.AreEqual("Ready", status!["mode"].ToString());
|
|
using (var noHeader = await server.Http.PutAsJsonAsync(new Uri("/api/settings/appearance.theme", UriKind.Relative), new { value = "dark" }))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.BadRequest, noHeader.StatusCode);
|
|
}
|
|
|
|
var csrf = await server.Http.GetFromJsonAsync<Dictionary<string, string>>(new Uri("/api/antiforgery", UriKind.Relative));
|
|
using (var request = new HttpRequestMessage(HttpMethod.Put, new Uri("/api/settings/appearance.theme", UriKind.Relative)) { Content = JsonContent.Create(new { value = "dark" }) })
|
|
{
|
|
request.Headers.Add(csrf!["header"], csrf["token"]);
|
|
using var put = await server.Http.SendAsync(request);
|
|
Assert.AreEqual(HttpStatusCode.NoContent, put.StatusCode);
|
|
}
|
|
|
|
StringAssert.Contains(await server.TextAsync("/"), "data-theme=\"dark\"");
|
|
|
|
// Secrets: status only, never the value.
|
|
var secret = await server.TextAsync("/api/secrets/ALPACA_API_KEY");
|
|
StringAssert.Contains(secret, "\"isSet\":false");
|
|
|
|
// Pause, resume, stop; resume never undoes "Ferma tutto".
|
|
Assert.AreEqual("paused", await BotAsync(server, csrf, "pause"));
|
|
Assert.AreEqual("active", await BotAsync(server, csrf, "resume"));
|
|
Assert.AreEqual("stopped", await BotAsync(server, csrf, "stop"));
|
|
Assert.IsNull(await BotAsync(server, csrf, "resume"));
|
|
|
|
// Sign out ends the session.
|
|
using (var bye = await server.PostFormAsync("/impostazioni", "/azioni/esci"))
|
|
{
|
|
Assert.AreEqual("/accesso", ServerHarness.Location(bye));
|
|
}
|
|
|
|
using var after = await server.GetAsync("/api/status");
|
|
Assert.AreEqual(HttpStatusCode.Unauthorized, after.StatusCode);
|
|
}
|
|
|
|
private static async Task<string?> BotAsync(ServerHarness server, Dictionary<string, string> csrf, string command)
|
|
{
|
|
using var request = new HttpRequestMessage(HttpMethod.Post, new Uri("/api/bot/" + command, UriKind.Relative));
|
|
request.Headers.Add(csrf["header"], csrf["token"]);
|
|
using var response = await server.Http.SendAsync(request);
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var body = await response.Content.ReadFromJsonAsync<Dictionary<string, string>>();
|
|
return body!["state"];
|
|
}
|
|
|
|
[TestMethod]
|
|
[DataRow("/impostazioni#aspetto", true)]
|
|
[DataRow("/?periodo=30", true)]
|
|
[DataRow("//evil.example", false)]
|
|
[DataRow("/\\evil.example", false)]
|
|
[DataRow("/\t/evil.example", false)]
|
|
[DataRow("/a\nb", false)]
|
|
[DataRow("https://evil.example", false)]
|
|
[DataRow("", false)]
|
|
public void ReturnAddressesStayOnTheSite(string path, bool local) => Assert.AreEqual(local, Forms.IsLocalPath(path));
|
|
|
|
[TestMethod]
|
|
public async Task ComputerOnlyModesRefuseForeignHostNames()
|
|
{
|
|
await using var server = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite(), extraArgs: ["--demo"]);
|
|
var demoRoot = server.Host.Config.Data.Root;
|
|
using (var mine = await server.GetAsync("/api/me"))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.OK, mine.StatusCode);
|
|
}
|
|
|
|
// DNS rebinding: a page whose name now points at 127.0.0.1 arrives from the loopback with its own Host.
|
|
using var request = new HttpRequestMessage(HttpMethod.Get, new Uri("/api/me", UriKind.Relative));
|
|
request.Headers.Host = "evil.example:" + server.BaseAddress.Port.ToString(System.Globalization.CultureInfo.InvariantCulture);
|
|
using var foreign = await server.Http.SendAsync(request);
|
|
Assert.AreEqual(HttpStatusCode.Forbidden, foreign.StatusCode);
|
|
TempFolder.Delete(demoRoot);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task RestoreFromTheErrorPageRestartsWithEverythingStopped()
|
|
{
|
|
var (env, postgres) = await ServerHarness.DockerOnEngineAsync();
|
|
await using var engine = postgres;
|
|
var data = TempFolder.Create("restore");
|
|
await using (var first = await ServerHarness.StartAsync("docker", env, dataDir: data))
|
|
{
|
|
await first.SignInFirstTimeAsync();
|
|
using var saved = await first.PostFormAsync("/impostazioni", "/azioni/salvataggio");
|
|
Assert.AreEqual("/impostazioni?ok=salvataggio#sistema", ServerHarness.Location(saved));
|
|
}
|
|
|
|
var backup = new Backups(new DataDirectory(data), new ManualClock(DemoMode.Now)).List().Single(b => b.Reason == "a-mano");
|
|
|
|
// An empty database takes the place of the real one; the data folder still belongs to the installation.
|
|
await using var empty = postgres is null ? null : await TestDb.CreateAsync(DbEngine.Postgres);
|
|
if (empty is null)
|
|
{
|
|
Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
|
|
var file = new DataDirectory(data).SqliteFile;
|
|
foreach (var f in Directory.EnumerateFiles(Path.GetDirectoryName(file)!))
|
|
{
|
|
File.Delete(f);
|
|
}
|
|
|
|
await File.WriteAllBytesAsync(file, []);
|
|
}
|
|
else
|
|
{
|
|
ServerHarness.UsePostgres(env, empty);
|
|
}
|
|
|
|
await using var server = await ServerHarness.StartAsync("docker", env, dataDir: data, waitReady: false);
|
|
await server.WaitForAsync(HostMode.IdentityProblem);
|
|
Assert.AreEqual(IdentityVerdict.EmptyDatabase, server.Host.Status.Identity!.Verdict);
|
|
using (var restore = await server.PostFormAsync("/", "/azioni/servizio/ripristina", ("password", ServerHarness.AdminPassword), ("salvataggio", backup.Name)))
|
|
{
|
|
Assert.AreEqual("/", ServerHarness.Location(restore));
|
|
}
|
|
|
|
await server.WaitForAsync(HostMode.Ready);
|
|
|
|
// SPEC 15.1: back with "Ferma tutto" on, a new fingerprint, and nobody signed in.
|
|
var state = await server.Host.Services!.Settings.GetAsync(SettingsStore.BotState.Key);
|
|
Assert.AreEqual("stopped", state.Value);
|
|
var row = await Installation.ReadRowAsync(server.Host.Services.Db);
|
|
Assert.IsTrue(row!.ProtectedRestart);
|
|
Assert.AreEqual(row.Fingerprint, Installation.ReadFile(new DataDirectory(data))!.Fingerprint);
|
|
Assert.AreEqual(0, await server.Host.Services.Db.ReadAsync(s => s.CountAsync("SELECT COUNT(*) FROM sessions")));
|
|
TempFolder.Delete(data);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task MissingConfigurationShowsTheErrorPageAndCreatesNoDatabase()
|
|
{
|
|
var env = ServerHarness.DockerSqlite();
|
|
env.Remove("ANUBIS_DB_ENGINE");
|
|
await using var server = await ServerHarness.StartAsync("docker", env, waitReady: false);
|
|
await server.WaitForAsync(HostMode.ConfigProblem);
|
|
|
|
using var page = await server.GetAsync("/qualsiasi/pagina");
|
|
var html = WebUtility.HtmlDecode(await page.Content.ReadAsStringAsync());
|
|
Assert.AreEqual(HttpStatusCode.ServiceUnavailable, page.StatusCode);
|
|
StringAssert.Contains(html, "Manca qualcosa nella configurazione d'avvio");
|
|
StringAssert.Contains(html, "ANUBIS_DB_ENGINE");
|
|
|
|
using var health = await server.GetAsync("/health");
|
|
Assert.AreEqual(HttpStatusCode.ServiceUnavailable, health.StatusCode);
|
|
|
|
// Trap 20: no database appears anywhere in the data folder.
|
|
Assert.IsEmpty(Directory.EnumerateFiles(server.DataDir, "*.sqlite3*", SearchOption.AllDirectories).ToList());
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task DetachedDatabaseShowsTheErrorPageAndTheAppResumesAlone()
|
|
{
|
|
await using var server = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite());
|
|
await server.SignInFirstTimeAsync();
|
|
var file = new DataDirectory(server.DataDir).SqliteFile;
|
|
var away = file + ".altrove";
|
|
|
|
Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
|
|
File.Move(file, away);
|
|
await server.WaitForAsync(HostMode.DatabaseUnavailable);
|
|
|
|
using (var page = await server.GetAsync("/"))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.ServiceUnavailable, page.StatusCode);
|
|
StringAssert.Contains(WebUtility.HtmlDecode(await page.Content.ReadAsStringAsync()), "Il database non risponde");
|
|
}
|
|
|
|
Assert.IsFalse(File.Exists(file), "No new empty database while the real one is away.");
|
|
|
|
File.Move(away, file);
|
|
await server.WaitForAsync(HostMode.Ready);
|
|
using var back = await server.GetAsync("/");
|
|
Assert.AreEqual(HttpStatusCode.OK, back.StatusCode, "Same session, no restart.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task EmptyDatabaseOfAKnownInstallationAsksTheUser()
|
|
{
|
|
var data = TempFolder.Create("identity");
|
|
await using (var first = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite(), dataDir: data))
|
|
{
|
|
await first.Http.GetAsync(new Uri("/health", UriKind.Relative));
|
|
}
|
|
|
|
// The database is replaced by an empty one; the data folder still belongs to the installation.
|
|
Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
|
|
var file = new DataDirectory(data).SqliteFile;
|
|
foreach (var f in Directory.EnumerateFiles(Path.GetDirectoryName(file)!))
|
|
{
|
|
File.Delete(f);
|
|
}
|
|
|
|
await File.WriteAllBytesAsync(file, []);
|
|
|
|
await using var server = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite(), dataDir: data, waitReady: false);
|
|
await server.WaitForAsync(HostMode.IdentityProblem);
|
|
var html = await server.TextAsync("/");
|
|
StringAssert.Contains(html, "Il database è vuoto");
|
|
StringAssert.Contains(html, "Comincia da capo");
|
|
|
|
using (var wrong = await server.PostFormAsync("/", "/azioni/servizio/da-capo", ("password", "wrong-password-123")))
|
|
{
|
|
StringAssert.Contains(ServerHarness.Location(wrong), "errore=password");
|
|
}
|
|
|
|
Assert.AreEqual(HostMode.IdentityProblem, server.Host.Status.Mode);
|
|
using (var ok = await server.PostFormAsync("/", "/azioni/servizio/da-capo", ("password", ServerHarness.AdminPassword)))
|
|
{
|
|
Assert.AreEqual("/", ServerHarness.Location(ok));
|
|
}
|
|
|
|
await server.WaitForAsync(HostMode.Ready);
|
|
Assert.IsNotEmpty(Directory.EnumerateFiles(data, "installation.json.precedente-*").ToList(), "The old identity is set aside, not deleted.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task DesktopStartsFromAnEmptyFolderAndKeepsTheKeyOutOfConfig()
|
|
{
|
|
await using var server = await ServerHarness.StartAsync("desktop", new Dictionary<string, string?>(), waitReady: false);
|
|
await server.WaitForAsync(HostMode.FirstRun);
|
|
|
|
using (var redirect = await server.GetAsync("/"))
|
|
{
|
|
Assert.AreEqual("/primo-avvio", ServerHarness.Location(redirect));
|
|
}
|
|
|
|
const string password = "fake-desktop-pass-3";
|
|
using (var done = await server.PostFormAsync("/primo-avvio", "/azioni/primo-avvio", ("motore", "sqlite"), ("password", password), ("conferma", password)))
|
|
{
|
|
Assert.AreEqual("/", ServerHarness.Location(done));
|
|
}
|
|
|
|
Assert.AreEqual(HostMode.Ready, server.Host.Status.Mode);
|
|
using (var home = await server.GetAsync("/"))
|
|
{
|
|
Assert.AreEqual(HttpStatusCode.OK, home.StatusCode, "Signed in by the wizard.");
|
|
}
|
|
|
|
var data = new DataDirectory(server.DataDir);
|
|
Assert.IsTrue(File.Exists(data.SqliteFile));
|
|
var config = await File.ReadAllTextAsync(data.ConfigFile);
|
|
StringAssert.Contains(config, "engine = \"sqlite\"");
|
|
StringAssert.Contains(config, "allow_live = false");
|
|
Assert.IsFalse(System.Text.RegularExpressions.Regex.IsMatch(config, @"^\s*\w*(secret|key|password)\w*\s*=", System.Text.RegularExpressions.RegexOptions.Multiline),
|
|
"Neither the secret key nor a password goes into config.toml.");
|
|
Assert.IsNotEmpty(Directory.EnumerateFiles(Path.Combine(data.Root, "keys")).ToList());
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task DemoModeNeverTouchesTheConfiguredDatabase()
|
|
{
|
|
// A real installation with its database, then the demo started with the same configuration.
|
|
var configured = TempFolder.Create("configured");
|
|
await using (var real = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite(), dataDir: configured))
|
|
{
|
|
await real.SignInFirstTimeAsync();
|
|
}
|
|
|
|
Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
|
|
var before = Snapshot(configured);
|
|
Assert.IsTrue(before.Keys.Any(k => k.EndsWith(".sqlite3", StringComparison.Ordinal)));
|
|
await using var server = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite(), dataDir: configured, extraArgs: ["--demo"]);
|
|
|
|
// Its own folder under the temporary directory, the configured one untouched.
|
|
var demoRoot = server.Host.Config.Data.Root;
|
|
StringAssert.StartsWith(demoRoot, Path.Combine(Path.GetTempPath(), "anubis-demo"));
|
|
|
|
// Appendix F on screen, frozen clock, signed in by itself, the footer says it.
|
|
var html = await server.TextAsync("/");
|
|
StringAssert.Contains(html, "+412,46 €");
|
|
StringAssert.Contains(html, "Venerdì 9 ottobre 2026, ore 08:21");
|
|
StringAssert.Contains(html, "Sorveglio 10 posizioni, ognuna con il suo stop.");
|
|
StringAssert.Contains(html, "Modalità dimostrativa. Numeri, titoli e notizie sono dati di esempio.");
|
|
|
|
// The live status arrives over the WebSocket.
|
|
using var socket = new ClientWebSocket();
|
|
await socket.ConnectAsync(new Uri(server.BaseAddress.ToString().Replace("http", "ws", StringComparison.Ordinal) + "ws"), CancellationToken.None);
|
|
var buffer = new byte[4096];
|
|
var received = await socket.ReceiveAsync(buffer, CancellationToken.None);
|
|
var message = Encoding.UTF8.GetString(buffer, 0, received.Count);
|
|
StringAssert.Contains(message, "\"type\":\"status\"");
|
|
StringAssert.Contains(message, "\"bot\":\"active\"");
|
|
await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None);
|
|
|
|
var after = Snapshot(configured);
|
|
CollectionAssert.AreEquivalent(before.Keys.ToList(), after.Keys.ToList(), "No file added or removed in the configured data folder.");
|
|
foreach (var (name, hash) in before)
|
|
{
|
|
Assert.AreEqual(hash, after[name], name + " changed");
|
|
}
|
|
|
|
TempFolder.Delete(demoRoot);
|
|
TempFolder.Delete(configured);
|
|
}
|
|
|
|
private static Dictionary<string, string> Snapshot(string folder) =>
|
|
Directory.EnumerateFiles(folder, "*", SearchOption.AllDirectories).ToDictionary(
|
|
f => Path.GetRelativePath(folder, f),
|
|
f => Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(File.ReadAllBytes(f))),
|
|
StringComparer.Ordinal);
|
|
|
|
[TestMethod]
|
|
public async Task DemoSeedRefusesAnyOtherDatabase()
|
|
{
|
|
var demo = DemoMode.CreateFolder(new Anubis.Core.SystemClock());
|
|
var elsewhere = TempFolder.Create("elsewhere");
|
|
await using var db = Database.Open(new DbSettings { Engine = DbEngine.Sqlite, SqlitePath = Path.Combine(elsewhere, "x.sqlite3") });
|
|
await Migrations.MigrateAsync(db, new ManualClock(DemoMode.Now), null, CancellationToken.None);
|
|
await Assert.ThrowsExactlyAsync<InvalidOperationException>(() => DemoMode.SeedAsync(db, demo, new ManualClock(DemoMode.Now)));
|
|
TempFolder.Delete(elsewhere);
|
|
TempFolder.Delete(demo.Root);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task HealthChecksDatabaseAndScheduler()
|
|
{
|
|
var (env, postgres) = await ServerHarness.DockerOnEngineAsync();
|
|
await using var engine = postgres;
|
|
await using var server = await ServerHarness.StartAsync("docker", env);
|
|
var health = await server.Http.GetFromJsonAsync<HealthResponse>(new Uri("/health", UriKind.Relative));
|
|
Assert.AreEqual("ok", health!.Status);
|
|
Assert.AreEqual("ok", health.Checks!["database"]);
|
|
Assert.AreEqual("ok", health.Checks["scheduler"]);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task SecurityHeadersAndLogoFromTheDesignFolder()
|
|
{
|
|
await using var server = await ServerHarness.StartAsync("docker", ServerHarness.DockerSqlite());
|
|
using var logo = await server.GetAsync("/brand/anubis.svg");
|
|
Assert.AreEqual(HttpStatusCode.OK, logo.StatusCode);
|
|
var served = await logo.Content.ReadAsByteArrayAsync();
|
|
CollectionAssert.AreEqual(await File.ReadAllBytesAsync(Path.Combine(Repo.Root.FullName, "docs", "design", "logo", "anubis.svg")), served);
|
|
Assert.Contains("frame-ancestors 'none'", logo.Headers.GetValues("Content-Security-Policy").Single());
|
|
Assert.AreEqual("nosniff", logo.Headers.GetValues("X-Content-Type-Options").Single());
|
|
|
|
// The typeface travels with the app, with its licence beside it (ADR 0004).
|
|
using var font = await server.GetAsync("/assets/InstrumentSans.ttf");
|
|
Assert.AreEqual(HttpStatusCode.OK, font.StatusCode);
|
|
Assert.AreEqual("font/ttf", font.Content.Headers.ContentType!.MediaType);
|
|
var fontPath = Path.Combine(Repo.Root.FullName, "src", "Anubis.Server", "Assets", "InstrumentSans.ttf");
|
|
CollectionAssert.AreEqual(await File.ReadAllBytesAsync(fontPath), await font.Content.ReadAsByteArrayAsync());
|
|
StringAssert.Contains(await server.TextAsync("/assets/InstrumentSans-OFL.txt"), "SIL Open Font License, Version 1.1");
|
|
StringAssert.Contains(await server.TextAsync("/assets/app.css"), "url(\"/assets/InstrumentSans.ttf\")");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task DatabaseCommandExportsAndImports()
|
|
{
|
|
var data = TempFolder.Create("cli");
|
|
var env = ServerHarness.DockerSqlite();
|
|
await using (var server = await ServerHarness.StartAsync("docker", env, dataDir: data))
|
|
{
|
|
await server.SignInFirstTimeAsync();
|
|
}
|
|
|
|
Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
|
|
var archive = Path.Combine(TempFolder.Create("cli-archive"), "archivio");
|
|
using var output = new StringWriter();
|
|
Assert.AreEqual(0, await DatabaseCommand.RunAsync(["export", archive, "--platform", "docker", "--data-dir", data], output, env), output.ToString());
|
|
|
|
var target = TempFolder.Create("cli-target");
|
|
Assert.AreEqual(0, await DatabaseCommand.RunAsync(["import", archive, "--platform", "docker", "--data-dir", target], output, env), output.ToString());
|
|
StringAssert.Contains(output.ToString(), "conteggi e totali coincidono");
|
|
Assert.IsTrue(File.Exists(new DataDirectory(target).InstallationFile));
|
|
|
|
// Import only into an empty database.
|
|
Assert.AreEqual(1, await DatabaseCommand.RunAsync(["import", archive, "--platform", "docker", "--data-dir", target], output, env));
|
|
TempFolder.Delete(data);
|
|
TempFolder.Delete(target);
|
|
TempFolder.Delete(Path.GetDirectoryName(archive)!);
|
|
}
|
|
}
|