using System.Net;
using System.Text.RegularExpressions;
using Anubis.Server;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
namespace Anubis.Tests;
///
/// The real server on a free local port, with a fake environment and its own data folder: never %APPDATA%, never
/// the developer's database. A cookie-keeping client that does not follow redirects, so tests see each step.
///
internal sealed partial class ServerHarness : IAsyncDisposable
{
public const string AdminPassword = "fake-initial-pass-1";
public const string SecretKey = "fake-secret-key-0123456789-abcdefghij";
private readonly WebApplication _app;
private bool _ownsData;
private ServerHarness(WebApplication app, string dataDir, CookieContainer cookies, HttpClient http)
{
_app = app;
DataDir = dataDir;
Cookies = cookies;
Http = http;
}
public string DataDir { get; }
public CookieContainer Cookies { get; }
public HttpClient Http { get; }
public Uri BaseAddress => Http.BaseAddress!;
internal AnubisHost Host => _app.Services.GetRequiredService();
/// Docker configuration with SQLite in the data folder: what most tests need.
public static Dictionary DockerSqlite() => new(StringComparer.Ordinal)
{
["ANUBIS_DB_ENGINE"] = "sqlite",
["ANUBIS_SECRET_KEY"] = SecretKey,
["ANUBIS_ADMIN_PASSWORD"] = AdminPassword,
["TZ"] = "Europe/Rome",
};
///
/// Docker configuration on the engine of this run (ANUBIS_TEST_DB): SQLite in the data folder, or a new PostgreSQL
/// database that the caller disposes.
///
public static async Task<(Dictionary Env, TestDb? Postgres)> DockerOnEngineAsync()
{
var env = DockerSqlite();
if (TestDatabase.Engine != "postgres")
{
return (env, null);
}
var db = await TestDb.CreateAsync(Anubis.Platform.DbEngine.Postgres).ConfigureAwait(false);
UsePostgres(env, db);
return (env, db);
}
public static void UsePostgres(Dictionary env, TestDb db)
{
ArgumentNullException.ThrowIfNull(env);
ArgumentNullException.ThrowIfNull(db);
env["ANUBIS_DB_ENGINE"] = "postgres";
env["ANUBIS_DB_HOST"] = db.Settings.Host;
env["ANUBIS_DB_PORT"] = db.Settings.Port.ToString(System.Globalization.CultureInfo.InvariantCulture);
env["ANUBIS_DB_NAME"] = db.Settings.Database;
env["ANUBIS_DB_USER"] = db.Settings.User;
env["ANUBIS_DB_PASSWORD"] = db.Settings.Password;
}
public static async Task StartAsync(string platform, IReadOnlyDictionary environment, string? dataDir = null,
string[]? extraArgs = null, bool waitReady = true, HttpMessageHandler? marketHttp = null, bool trading = false, HttpMessageHandler? telegramHttp = null)
{
var owns = dataDir is null;
dataDir ??= TempFolder.Create("server");
string[] args = ["--platform", platform, "--data-dir", dataDir, "--urls", "http://127.0.0.1:0", .. extraArgs ?? []];
var app = ServerApp.Build(args, new ServerOverrides
{
Environment = environment,
PasswordIterations = 1000,
DatabaseCheckInterval = TimeSpan.FromMilliseconds(100),
MarketData = marketHttp is not null,
MarketHttp = marketHttp,
MarketSockets = marketHttp is null ? null : () => new FakeSocket(),
Trading = trading,
TelegramHttp = telegramHttp,
});
await app.StartAsync().ConfigureAwait(false);
var cookies = new CookieContainer();
#pragma warning disable CA2000 // The handler belongs to the client, disposed with the harness.
var http = new HttpClient(new HttpClientHandler { CookieContainer = cookies, AllowAutoRedirect = false })
#pragma warning restore CA2000
{
BaseAddress = new Uri(app.Urls.Single()),
Timeout = TimeSpan.FromSeconds(60),
};
var harness = new ServerHarness(app, dataDir, cookies, http) { _ownsData = owns };
if (waitReady)
{
await harness.Host.WaitForAsync(HostMode.Ready, TimeSpan.FromSeconds(30)).ConfigureAwait(false);
}
return harness;
}
public async Task WaitForAsync(HostMode mode) => await Host.WaitForAsync(mode, TimeSpan.FromSeconds(30)).ConfigureAwait(false);
public Task GetAsync(string path) => Http.GetAsync(new Uri(path, UriKind.Relative));
public async Task TextAsync(string path)
{
using var response = await GetAsync(path).ConfigureAwait(false);
return WebUtility.HtmlDecode(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
}
/// The CSRF field of a page's forms.
public async Task CsrfAsync(string page)
{
using var response = await GetAsync(page).ConfigureAwait(false);
var html = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var match = CsrfField().Match(html);
Assert.IsTrue(match.Success, "No CSRF field on " + page);
return WebUtility.HtmlDecode(match.Groups[1].Value);
}
/// Posts a form the way the browser does, with the CSRF field of .
public async Task PostFormAsync(string page, string action, params (string Name, string Value)[] fields)
{
var token = await CsrfAsync(page).ConfigureAwait(false);
using var content = new FormUrlEncodedContent([new("__csrf", token), .. fields.Select(f => new KeyValuePair(f.Name, f.Value))]);
return await Http.PostAsync(new Uri(action, UriKind.Relative), content).ConfigureAwait(false);
}
/// Signs in with the initial password and replaces it, as the first access in Docker requires.
public async Task SignInFirstTimeAsync()
{
using (var login = await PostFormAsync("/accesso", "/azioni/accesso", ("password", AdminPassword)).ConfigureAwait(false))
{
Assert.AreEqual(HttpStatusCode.Redirect, login.StatusCode);
}
const string chosen = "chosen-test-pass-2";
using var change = await PostFormAsync("/primo-accesso", "/azioni/primo-accesso", ("attuale", AdminPassword), ("nuova", chosen), ("conferma", chosen))
.ConfigureAwait(false);
Assert.AreEqual("/?ok=password", change.Headers.Location?.OriginalString);
return chosen;
}
public static string Location(HttpResponseMessage response) => response.Headers.Location?.OriginalString ?? "";
public async ValueTask DisposeAsync()
{
Http.Dispose();
await _app.StopAsync().ConfigureAwait(false);
await _app.DisposeAsync().ConfigureAwait(false);
if (_ownsData)
{
TempFolder.Delete(DataDir);
}
}
[GeneratedRegex("name=\"__csrf\" value=\"([^\"]+)\"")]
private static partial Regex CsrfField();
}