using System.Diagnostics; using System.Net.Sockets; [assembly: Parallelize(Scope = ExecutionScope.MethodLevel)] namespace Anubis.Tests; /// Test categories (ADR 0003). never runs in the normal suite. internal static class Category { public const string Unit = "Unit"; public const string Integration = "Integration"; public const string Simulation = "Simulation"; public const string LiveDemo = "LiveDemo"; public const string Golden = "Golden"; } /// Locates the repository so policy tests can read its files. internal static class Repo { public static DirectoryInfo Root { get; } = FindRoot(); private static DirectoryInfo FindRoot() { for (var dir = new DirectoryInfo(AppContext.BaseDirectory); dir is not null; dir = dir.Parent) { if (File.Exists(Path.Combine(dir.FullName, "Anubis.slnx"))) { return dir; } } throw new InvalidOperationException("Repository root (Anubis.slnx) not found above " + AppContext.BaseDirectory); } private static readonly Lazy> _files = new(ListFiles); /// /// The files git would commit: tracked ones plus new ones that .gitignore does not exclude. /// The local .env, /data and build output stay out, so a key the user puts there never fails the suite. /// public static IEnumerable Files() => _files.Value; private static List ListFiles() { var info = new ProcessStartInfo("git") { WorkingDirectory = Root.FullName, RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false, }; foreach (var argument in new[] { "ls-files", "-z", "--cached", "--others", "--exclude-standard" }) { info.ArgumentList.Add(argument); } using var process = Process.Start(info) ?? throw new InvalidOperationException("git could not be started."); var errors = process.StandardError.ReadToEndAsync(); var output = process.StandardOutput.ReadToEnd(); process.WaitForExit(); if (process.ExitCode != 0) { throw new InvalidOperationException("git ls-files failed: " + errors.Result); } return output.Split('\0', StringSplitOptions.RemoveEmptyEntries) .Select(path => new FileInfo(Path.Combine(Root.FullName, path))) .Where(file => file.Exists) .ToList(); } public static string Relative(FileInfo file) => Path.GetRelativePath(Root.FullName, file.FullName).Replace('\\', '/'); } /// Database engine the suite runs against: ANUBIS_TEST_DB = sqlite (default) or postgres. internal static class TestDatabase { public static string Engine { get; } = (Environment.GetEnvironmentVariable("ANUBIS_TEST_DB") ?? "sqlite").Trim().ToLowerInvariant(); /// Host and port of the PostgreSQL used by the tests, from ANUBIS_TEST_PG_HOST and ANUBIS_TEST_PG_PORT. public static (string Host, int Port) Postgres { get; } = ( Environment.GetEnvironmentVariable("ANUBIS_TEST_PG_HOST") ?? "127.0.0.1", int.TryParse(Environment.GetEnvironmentVariable("ANUBIS_TEST_PG_PORT"), out var port) ? port : 55432); public static async Task PostgresReachableAsync(TimeSpan timeout) { using var client = new TcpClient(); using var cts = new CancellationTokenSource(timeout); try { await client.ConnectAsync(Postgres.Host, Postgres.Port, cts.Token).ConfigureAwait(false); return true; } catch (Exception ex) when (ex is SocketException or OperationCanceledException) { return false; } } } /// /// A fresh, empty database for one test: a SQLite file in a temporary folder, or a new PostgreSQL database /// created on the test server and dropped afterwards. Never the developer's or the user's database. /// internal sealed class TestDb : IAsyncDisposable { private readonly string? _folder; private readonly string? _postgresName; private TestDb(Anubis.Platform.DbSettings settings, string? folder, string? postgresName) { Settings = settings; _folder = folder; _postgresName = postgresName; Db = Anubis.Db.Database.Open(settings); } public Anubis.Platform.DbSettings Settings { get; } public Anubis.Db.Database Db { get; } public static string PostgresPassword { get; } = Environment.GetEnvironmentVariable("ANUBIS_TEST_PG_PASSWORD") ?? "anubis-dev"; /// A database on the engine of this run (ANUBIS_TEST_DB). public static Task CreateAsync() => CreateAsync(TestDatabase.Engine == "postgres" ? Anubis.Platform.DbEngine.Postgres : Anubis.Platform.DbEngine.Sqlite); public static async Task CreateAsync(Anubis.Platform.DbEngine engine) { if (engine == Anubis.Platform.DbEngine.Sqlite) { var folder = TempFolder.Create("db"); return new TestDb(new() { Engine = engine, SqlitePath = Path.Combine(folder, "test.sqlite3") }, folder, null); } var name = "anubis_t_" + Guid.NewGuid().ToString("N"); await using (var admin = Anubis.Db.Database.Open(AdminSettings())) { await using var connection = await admin.OpenConnectionAsync(CancellationToken.None).ConfigureAwait(false); await using var command = connection.CreateCommand(); command.CommandText = $"CREATE DATABASE {name}"; await command.ExecuteNonQueryAsync().ConfigureAwait(false); } return new TestDb(AdminSettings() with { Database = name }, null, name); } /// True when a PostgreSQL server for tests answers: cross-engine tests run only then. public static Task PostgresAvailableAsync() => TestDatabase.PostgresReachableAsync(TimeSpan.FromSeconds(5)); private static Anubis.Platform.DbSettings AdminSettings() => new() { Engine = Anubis.Platform.DbEngine.Postgres, Host = TestDatabase.Postgres.Host, Port = TestDatabase.Postgres.Port, Database = "anubis", User = "anubis", Password = PostgresPassword, }; public async ValueTask DisposeAsync() { await Db.DisposeAsync().ConfigureAwait(false); if (_postgresName is not null) { await using var admin = Anubis.Db.Database.Open(AdminSettings()); await using var connection = await admin.OpenConnectionAsync(CancellationToken.None).ConfigureAwait(false); await using var command = connection.CreateCommand(); command.CommandText = $"DROP DATABASE IF EXISTS {_postgresName} WITH (FORCE)"; await command.ExecuteNonQueryAsync().ConfigureAwait(false); } if (_folder is not null) { TempFolder.Delete(_folder); } } } /// Temporary folders for tests, under the system temp directory. internal static class TempFolder { public static string Create(string purpose) { var path = Path.Combine(Path.GetTempPath(), "anubis-tests", purpose + "-" + Guid.NewGuid().ToString("N")[..12]); Directory.CreateDirectory(path); return path; } public static void Delete(string path) { Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools(); for (var attempt = 0; attempt < 5; attempt++) { try { if (Directory.Exists(path)) { Directory.Delete(path, recursive: true); } return; } catch (IOException) when (attempt < 4) { Thread.Sleep(100); } catch (UnauthorizedAccessException) when (attempt < 4) { Thread.Sleep(100); } } } }