Files
Chronos/tests/Chronos.Server.Tests/TestServer.cs
T
Alby96 0e84392f4f feat(logs): log level, retention, size limits and rotation on server and desktop
Owner review 2, R11 asked for more log settings. The file sink now writes daily or
hourly files, continues a full file in numbered parts and prunes by age and by the
total size (never the file being written); its options change while it runs.

Server: the file and console levels are separate and read by the logging filters
at every line, so the admin panel's new Logs group applies without a restart; the
engine's level follows the lower of the two. This also fixes a bug: the file logger
was fixed at Information, so CHRONOS_LOG_LEVEL=Debug or Trace never reached the
files. New variables CHRONOS_LOG_CONSOLE_LEVEL, CHRONOS_LOG_RETENTION_DAYS,
CHRONOS_LOG_MAX_FILE_MB, CHRONOS_LOG_MAX_TOTAL_MB, CHRONOS_LOG_ROTATION,
CHRONOS_AUDIT_RETENTION_DAYS and CHRONOS_DIAGNOSTICS_LOG_MB lock their settings like
the others; the diagnostics zip keeps the configured share of each log.

Desktop: Settings > Advanced gains Log level, Keep logs, File size, Logs total,
Rotation and Diagnostics logs, applied at every save; Advanced's Reset section
restores them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit cc875784e4952ee0e4c807b9d9c18496d3d5a8c3)
2026-10-27 02:08:09 +01:00

155 lines
7.1 KiB
C#

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Protocol;
using Chronos.Server.Configuration;
using Chronos.Server.Hosting;
using Chronos.Server.Storage;
using Chronos.Testing;
namespace Chronos.Server.Tests;
/// <summary>
/// In-process Kestrel on ephemeral ports with temporary archive/data folders and a SQLite database (BRIEF §20.1).
/// The archive module is replaced by <see cref="FakeArchiveIngest"/> and <see cref="FakeAssetLocator"/>.
/// </summary>
public sealed class TestServer : IAsyncDisposable
{
public const string AdminPassword = "first-admin-pass";
public const string Password = "a-good-password-1";
private readonly WebApplication _app;
private readonly List<HttpClient> _clients = [];
private string _adminPassword = AdminPassword;
private TestServer(WebApplication app, ServerOptions options, Uri http, Uri? https)
{
_app = app;
Options = options;
HttpBase = http;
HttpsBase = https;
Client = NewClient();
}
public ServerOptions Options { get; }
public Uri HttpBase { get; }
public Uri? HttpsBase { get; }
/// <summary>An anonymous client.</summary>
public HttpClient Client { get; }
public IServiceProvider Services => _app.Services;
public ChronosDatabase Database => Services.GetRequiredService<ChronosDatabase>();
public static async Task<TestServer> StartAsync(TestContext context, Action<ServerOptions>? configure = null, Action<IServiceCollection>? services = null)
{
var root = context.CreateTempDirectory("server");
var options = new ServerOptions
{
DataPath = Path.Combine(root, "data"),
ArchivePath = Path.Combine(root, "archive"),
HttpPort = 0,
HttpsPort = 0,
TlsMode = TlsMode.Auto,
Database = DatabaseKind.Sqlite,
Discovery = false,
Parallelism = 2,
AdminUser = "admin",
AdminPassword = AdminPassword,
// Tests sign in many times from one address; the rate-limit test sets the production value.
LoginAttemptsPerMinute = 1000,
// Info lines of the ~55 servers the suite starts would bury failures in the CI log.
LogLevel = Microsoft.Extensions.Logging.LogLevel.Warning,
ConsoleLogLevel = Microsoft.Extensions.Logging.LogLevel.Warning,
};
Directory.CreateDirectory(options.ArchivePath);
configure?.Invoke(options);
var app = ServerHost.Build(options, [], s =>
{
s.AddSingleton<FakeArchiveIngest>();
s.TryAddSingleton<IArchiveIngest>(sp => sp.GetRequiredService<FakeArchiveIngest>());
s.AddSingleton<FakeAssetLocator>();
s.TryAddSingleton<IFrameAssetLocator>(sp => sp.GetRequiredService<FakeAssetLocator>());
services?.Invoke(s);
});
await app.StartAsync(context.Cancellation);
var addresses = app.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>()!.Addresses
.Select(a => new Uri(a.Replace("[::]", "127.0.0.1", StringComparison.Ordinal).Replace("0.0.0.0", "127.0.0.1", StringComparison.Ordinal)))
.ToList();
var http = addresses.First(a => a.Scheme == "http");
var https = addresses.FirstOrDefault(a => a.Scheme == "https");
return new TestServer(app, options, http, https);
}
/// <summary>A plain HTTP client (owned by the server, disposed with it).</summary>
public HttpClient NewClient(string? token = null)
{
var client = new HttpClient { BaseAddress = HttpBase, Timeout = TimeSpan.FromSeconds(60) };
if (token is not null) client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
_clients.Add(client);
return client;
}
/// <summary>An HTTPS client with a cookie jar that trusts the self-signed certificate (admin panel sessions).</summary>
public HttpClient NewCookieClient(CookieContainer cookies)
{
var handler = new HttpClientHandler { CookieContainer = cookies, ServerCertificateCustomValidationCallback = (_, _, _, _) => true };
var client = new HttpClient(handler) { BaseAddress = HttpsBase, Timeout = TimeSpan.FromSeconds(60) };
_clients.Add(client);
return client;
}
public async Task<LoginResponse> LoginAsync(string username, string password, string clientName = "tests")
{
using var response = await Client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest(username, password, clientName), ProtocolJson.Default.LoginRequest);
if (!response.IsSuccessStatusCode) throw new InvalidOperationException($"Login of {username} failed: {(int)response.StatusCode} {await response.Content.ReadAsStringAsync()}");
return (await response.Content.ReadFromJsonAsync(ProtocolJson.Default.LoginResponse))!;
}
/// <summary>The bootstrap administrator, signed in; its first sign-in replaces the bootstrap password with <see cref="Password"/>.</summary>
public async Task<HttpClient> AdminAsync()
{
var login = await LoginAsync("admin", _adminPassword);
var client = NewClient(login.Token);
if (login.MustChangePassword)
{
using var changed = await client.PostAsJsonAsync("/api/v1/auth/password", new ChangePasswordRequest(_adminPassword, Password),
ProtocolJson.Default.ChangePasswordRequest);
changed.EnsureSuccessStatusCode();
_adminPassword = Password;
}
return client;
}
/// <summary>Creates a user (through the admin API) who has set <see cref="Password"/>, and returns a client signed in as them.</summary>
public async Task<(HttpClient Client, UserDto User, string Token)> UserAsync(string username, string role, long quotaBytes = 0, bool renderNode = false)
{
var admin = await AdminAsync();
using var created = await admin.PostAsJsonAsync("/api/v1/users", new CreateUserRequest(username, null, role, quotaBytes, null, renderNode),
ProtocolJson.Default.CreateUserRequest);
created.EnsureSuccessStatusCode();
var temporary = (await created.Content.ReadFromJsonAsync(ProtocolJson.Default.TemporaryPasswordResponse))!;
var first = await LoginAsync(username, temporary.TemporaryPassword);
var client = NewClient(first.Token);
using var changed = await client.PostAsJsonAsync("/api/v1/auth/password", new ChangePasswordRequest(temporary.TemporaryPassword, Password),
ProtocolJson.Default.ChangePasswordRequest);
changed.EnsureSuccessStatusCode();
return (client, temporary.User, first.Token!);
}
public async ValueTask DisposeAsync()
{
foreach (var client in _clients) client.Dispose();
await _app.StopAsync();
await _app.DisposeAsync();
}
}