Covers bootstrap admin, sign-in failure, lockout and rate limit, token revocation and expiry, 401 versus 403, CSRF on cookie sessions, the error shape and API header, chunked upload happy path, resume, hash short-circuit, damaged chunk, quota, Range on originals, thumbnails and exports, path traversal, settings_version conflicts, job state transitions with a fake handler, render node claim, heartbeat timeout and reassignment, output upload, WebSocket progress events, the discovery beacon, the Windows service command line and status rules, and a PostgreSQL run (TITANO_TEST_PG). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
152 lines
6.9 KiB
C#
152 lines
6.9 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 Titano.Data;
|
|
using Titano.Data.Archiving;
|
|
using Titano.Protocol;
|
|
using Titano.Server.Configuration;
|
|
using Titano.Server.Hosting;
|
|
using Titano.Server.Storage;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.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 TitanoDatabase Database => Services.GetRequiredService<TitanoDatabase>();
|
|
|
|
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,
|
|
Workers = 2,
|
|
AdminUser = "admin",
|
|
AdminPassword = AdminPassword,
|
|
// Tests sign in many times from one address; the rate-limit test sets the production value.
|
|
LoginAttemptsPerMinute = 1000,
|
|
};
|
|
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();
|
|
}
|
|
}
|