Positions crossing copies could still land on other photos in three windows: - A push translated a row snapshot's settings against local frames listed later, after a manifest round trip: an import of earlier photos meanwhile moved the row's positions, and the server stored shifted exclusions, hero and keyframes. SyncPositions now reads this copy's row with its frames as one state (frames listed between two reads of the row at the same frames version) and translates that row's settings, at the settings version being pushed. The conflict comparison and ApplyLocallyAsync compare against that same row. When the copy was edited since, or its frames keep changing, nothing is sent or applied and the next comparison translates again (Keep mine reports a changed conflict; PushAll sends an edit saved meanwhile). - The manifest read the sequence row, then paged its frames: an upload committed in between paired settings of one frames version with frames of the next. The server now lists them again while the frames version moved during the listing, then inside a transaction holding the row (on SQLite, on that transaction's connection, so no second pooled connection waits behind the write lock). The client also refuses to translate against a manifest whose frames are not each listed once at 0..n-1. - Server capture times were fetched only when something was unhashed, so the same parked photo was written with or without capturedAt. They are now fetched whenever the two frame lists differ; an equal project then compares equal, and an entry can be placed on a photo that arrives unhashed. CompareOriginals counted unhashed server frames one-to-one against this PC's photos, so two copies of one photo in a folder the server adopted left Download on offer forever while the download fetched nothing. A photo on either side is now there when any photo of the other side matches it, as downloads and uploads find them. Paged frame listings keep each frame once (an insertion between pages lists one again). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
103 lines
4.8 KiB
C#
103 lines
4.8 KiB
C#
using System.Net;
|
|
using System.Net.Http.Json;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Titano.Core.Model;
|
|
using Titano.Data;
|
|
using Titano.Data.Jobs;
|
|
using Titano.Protocol;
|
|
using Titano.Server.Configuration;
|
|
using Titano.Server.Tests.Jobs;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.Server.Tests.Postgres;
|
|
|
|
/// <summary>The server on PostgreSQL (<c>TITANO_TEST_PG</c>), each test in a private schema.</summary>
|
|
[Category("server")]
|
|
[RequiresEnvironment("TITANO_TEST_PG")]
|
|
public sealed class PostgresServerTests(TestContext context)
|
|
{
|
|
[Test]
|
|
public async Task SignInUploadSyncAndJobsWorkOnPostgres()
|
|
{
|
|
await using var schema = await Schema.CreateAsync(context);
|
|
var handler = new BlockingJobHandler(JobKind.Thumbs);
|
|
await using var server = await TestServer.StartAsync(context, o =>
|
|
{
|
|
o.Database = DatabaseKind.Postgres;
|
|
o.DbConnectionString = schema.ConnectionString;
|
|
o.ChunkSizeBytes = 64 * 1024;
|
|
}, s => s.AddSingleton<IJobHandler>(handler));
|
|
Assert.Equal(Dialect.Postgres, server.Database.Dialect);
|
|
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor", quotaBytes: 10_000_000);
|
|
var data = Uploads.Photo(150_000, 71);
|
|
var frame = await Uploads.UploadAsync(editor, data, sessionKey: "pg");
|
|
using (var manifest = await editor.GetAsync($"/api/v1/sequences/{frame.SequenceId}/manifest"))
|
|
Assert.Equal(Uploads.Sha(data), (await manifest.ReadAsync(ProtocolJson.Default.SequenceManifest)).Frames.Single().Sha256);
|
|
using (var me = await editor.GetAsync("/api/v1/auth/me")) Assert.Equal(data.Length, (await me.ReadAsync(ProtocolJson.Default.UserDto)).UsedBytes);
|
|
|
|
using (var stale = await editor.PatchAsJsonAsync($"/api/v1/sequences/{frame.SequenceId}", new UpdateSequenceRequest(null, ["pg"], null, null, "{}", 99),
|
|
ProtocolJson.Default.UpdateSequenceRequest))
|
|
await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "settings_conflict");
|
|
|
|
// Uploading queued a background thumbnail job for the sequence; it runs on the server's engine.
|
|
using var queued = await editor.GetAsync("/api/v1/jobs?kind=thumbs");
|
|
var job = (await queued.ReadAsync(ProtocolJson.Default.PageJobDto)).Items.Single();
|
|
await JobApiTests.WaitForAsync(editor, job.Id, "running");
|
|
handler.Release();
|
|
await JobApiTests.WaitForAsync(editor, job.Id, "done");
|
|
|
|
var admin = await server.AdminAsync();
|
|
using var dashboard = await admin.GetAsync("/api/v1/server/dashboard");
|
|
Assert.True((await dashboard.ReadAsync(ProtocolJson.Default.DashboardDto)).Database.StartsWith("PostgreSQL ", StringComparison.Ordinal));
|
|
using var health = await server.Client.GetAsync("/health");
|
|
Assert.Equal("ok", (await health.ReadAsync(ProtocolJson.Default.HealthStatus)).Checks["database"]);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheManifestListsTheFramesOfOneFramesVersionOnPostgres()
|
|
{
|
|
await using var schema = await Schema.CreateAsync(context);
|
|
await using var server = await TestServer.StartAsync(context, o =>
|
|
{
|
|
o.Database = DatabaseKind.Postgres;
|
|
o.DbConnectionString = schema.ConnectionString;
|
|
});
|
|
Assert.Equal(Dialect.Postgres, server.Database.Dialect);
|
|
await Api.SequenceTests.FramesOfOneVersionAsync(server);
|
|
}
|
|
|
|
/// <summary>A throw-away schema on the test server, selected through <c>Search Path</c>.</summary>
|
|
private sealed class Schema : IAsyncDisposable
|
|
{
|
|
private readonly IDatabase _admin;
|
|
private readonly string _name;
|
|
|
|
private Schema(IDatabase admin, string name, string connectionString)
|
|
{
|
|
_admin = admin;
|
|
_name = name;
|
|
ConnectionString = connectionString;
|
|
}
|
|
|
|
public string ConnectionString { get; }
|
|
|
|
public static async Task<Schema> CreateAsync(TestContext context)
|
|
{
|
|
var baseConnection = Environment.GetEnvironmentVariable("TITANO_TEST_PG")!;
|
|
var admin = DatabaseFactory.Open(DatabaseOptions.Postgres(baseConnection));
|
|
var name = "titano_s_" + Guid.NewGuid().ToString("N")[..16];
|
|
await using (var session = await admin.OpenAsync(context.Cancellation))
|
|
await session.ExecuteScriptAsync($"CREATE SCHEMA {name}", context.Cancellation);
|
|
return new Schema(admin, name, baseConnection.TrimEnd(';', ' ') + $";Search Path={name}");
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
await using (var session = await _admin.OpenAsync(CancellationToken.None))
|
|
await session.ExecuteScriptAsync($"DROP SCHEMA IF EXISTS {_name} CASCADE", CancellationToken.None);
|
|
await _admin.DisposeAsync();
|
|
}
|
|
}
|
|
}
|