Files
Chronos/tests/Titano.App.Tests/Editor/ExportSyncTests.cs
T
Claude 757695f037 fix(editor): server jobs, stale proxies and read-only accounts in the remote editor
- A server sequence whose cached frames are no longer the server's (a load, a 409
  merge or a frames change event finds other frame ids) turns read-only and says
  why; opening it, or a sequence without cached proxies, queues the proxy
  download and opens it when done. Signed out reads "Connect to the server".
- Server jobs show queued, running (with a bar), paused and analysing glyphs in
  the header with Cancel; a failed or cancelled one raises a toast with Retry.
  Progress alone no longer refreshes the whole editor.
- The server job list is read by state and kind to its last page; "Add to queue"
  sets the job's priority; the event listener survives any failure and always
  releases its frames and connection.
- An account that may render but not edit picks the preset to render without
  changing the project; preset cards and their batch boxes say why they wait.
- Export tab of a server sequence: no local encoder, notices or folder; no Jobs
  history link. Sync at 12 px beside a folder that keeps 96 px and trims.
- Restore's Undo puts back the project from before the restore, only while that
  restore is the editor's last change.
- Export "Sync" of a render that ends while the session is down is queued for the
  saved session's server; skips are logged; sync follows the engine before it
  starts.
- Capture: sequence-remote-export, -running and -readonly, and
  sequence-export-copies.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-05 22:15:34 +00:00

77 lines
4.3 KiB
C#

using System.IO;
using Titano.App.Editor;
using Titano.Core.Model;
using Titano.Core.Project;
using Titano.Data;
using Titano.Data.Archiving;
using Titano.Data.Jobs;
using Titano.Data.Processing;
using Titano.Data.Sync;
using Titano.Testing;
namespace Titano.App.Tests.Editor;
/// <summary>Export "Sync" (Export.html): when it applies, how the project remembers it, and the send it queues after a render.</summary>
public sealed class ExportSyncTests(TestContext context)
{
private const string Server = "https://nas.test:8443";
[Test]
public void TheOptionSaysWhyItCannotBeUsed()
{
Assert.Equal(ExportSyncGate.Available, ExportSync.Gate(false, Server, linked: true, canUpload: true));
Assert.Equal(ExportSyncGate.Remote, ExportSync.Gate(true, Server, linked: true, canUpload: true));
Assert.Equal(ExportSyncGate.SignedOut, ExportSync.Gate(false, null, linked: false, canUpload: false));
Assert.Equal(ExportSyncGate.NotLinked, ExportSync.Gate(false, Server, linked: false, canUpload: true));
Assert.Equal(ExportSyncGate.NoUpload, ExportSync.Gate(false, Server, linked: true, canUpload: false));
}
[Test]
public void TheProjectRemembersTheChoiceAndOlderProjectsReadItOff()
{
Assert.False(new ProjectSettings().Export.SyncToServer, "renders travel on request");
Assert.False(ProjectSettings.FromJson("""{"export":{"nameTemplate":"{title}"}}""").Export.SyncToServer);
var chosen = new ProjectSettings { Export = new ExportSettings { SyncToServer = true } };
Assert.Contains("\"syncToServer\": true", chosen.ToJson());
Assert.True(ProjectSettings.FromJson(chosen.ToJson()).Export.SyncToServer);
}
[Test]
public async Task AFinishedRenderIsSentOnlyWhenAskedLinkedAndAllowed()
{
var directory = context.CreateTempDirectory("export-sync");
await using var db = await TitanoDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")));
var archives = new ArchiveService(db, new ArchiveServiceOptions { Owner = "test" });
var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Test");
var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = archive.Id, Title = "Harbour sunset", Folder = "Harbour", FrameCount = 1 };
await db.Sequences.UpsertAsync(sequence);
var sync = new SyncService(db, archives, new SyncOptions { ProxyCacheDirectory = Path.Combine(directory, "proxies") });
await using var engine = new JobEngine(db, [], new JobEngineOptions { WorkerId = "test" });
var exports = new ExportSync(db, sync, engine);
Job Render(bool syncToServer, JobState state = JobState.Done) => new()
{
Id = Guid.CreateVersion7(),
Kind = JobKind.Render,
TargetIds = [sequence.Id],
ParametersJson = ProcessingJobs.Render(sequence, new ExportSettings { SyncToServer = syncToServer }, 1920, 1080).ParametersJson,
State = state,
};
Assert.Equal(ExportSyncGate.NotLinked, (await exports.SendAsync(Render(true), Server, canUpload: true))?.Gate, "the server does not have the sequence");
await sync.LinkAsync(Server, Guid.CreateVersion7(), sequence.Id);
Assert.Null(await exports.SendAsync(Render(false), Server, canUpload: true), "the export did not ask for it");
Assert.Equal(ExportSyncGate.SignedOut, (await exports.SendAsync(Render(true), null, canUpload: true))?.Gate, "no session, saved or open");
Assert.Equal(ExportSyncGate.NoUpload, (await exports.SendAsync(Render(true), Server, canUpload: false))?.Gate, "no Upload right");
Assert.Null(await exports.SendAsync(Render(true, JobState.Failed), Server, canUpload: true), "nothing was rendered");
var result = Assert.NotNull(await exports.SendAsync(Render(true), Server, canUpload: true));
Assert.Equal(ExportSyncGate.Available, result.Gate);
var send = Assert.NotNull(result.Send);
Assert.Equal(JobKind.UploadCommit, send.Kind);
Assert.Equal(SyncTransferKind.SendExports, SyncService.TransferKind(send));
Assert.SequenceEqual([sequence.Id], send.TargetIds);
Assert.Equal(send.Id, (await exports.SendAsync(Render(true), Server, canUpload: true))?.Send?.Id, "a send already waiting takes the next render too");
}
}