Files
Chronos/tests/Chronos.Data.Tests/Projects/ProjectRecoveryTests.cs
T
Alby96andClaude Opus 5.5 9b24cf74fc
CI / Build and test (push) Successful in 9m43s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 27s
CI / PostgreSQL 16 integration (push) Failing after 8m41s
CI / PostgreSQL 17 integration (push) Successful in 12m37s
CI / Docker image (push) Successful in 56s
Release / Build, test and publish (push) Successful in 14m59s
Release / Server image (push) Successful in 1m51s
feat: owner review 2 phase 5a: workspace and projects with a local home (#14)
Edit opens a sequence as a project of a workspace folder outside the library. Projects have linear version histories kept as sidecars in .chronos/projects/, Main mirrors the sequence's settings, and sync merges setting by setting. Migration 0009, JobKind.WorkspaceCopy = 20, Settings › Workspace, and 241 new strings in 38 languages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-11-04 09:22:08 +01:00

1170 lines
74 KiB
C#

using System.Security.Cryptography;
using Chronos.Core.Archiving;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Archiving;
using Chronos.Data.Projects;
using Chronos.Data.Tests.Archiving;
using Chronos.Data.Tests.Infrastructure;
using Chronos.Data.Tests.Workspaces;
using Chronos.Data.Workspaces;
using Chronos.Testing;
using static Chronos.Data.Tests.Archiving.ArchiveFixture;
using static Chronos.Data.Tests.Projects.ProjectServiceTests;
namespace Chronos.Data.Tests.Projects;
/// <summary>
/// The sidecars stay the truth of a sequence's projects when they cannot be read, are missing, are a newer Chronos's, or
/// sit on a read-only archive, and an index that meets them late never takes its own old copy for the sequence's settings.
/// </summary>
[Category("projects")]
public abstract class ProjectRecoveryTests(TestContext context) : DatabaseTest(context)
{
private async Task<ArchiveFixture> FixtureAsync() => Own(await CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
/// <summary>The live project folders of a sequence (one per project).</summary>
private static string[] ProjectFolders(SequencePaths folder) =>
[.. Directory.GetDirectories(folder.ProjectsDirectory).Where(d => Guid.TryParseExact(Path.GetFileName(d), "N", out _))];
private static int MainRecords(SequencePaths folder) =>
ProjectFolders(folder).Count(d => ProjectSidecars.ReadRecord(Path.Combine(d, "project.json")).IsMain);
private static ProjectSettings Settings(ArchiveFixture fx, Sequence sequence) =>
ProjectSettings.FromJson(File.ReadAllText(fx.Paths.Sequence(sequence.Folder).ProjectPath));
[Test]
public async Task ARecordThatCannotBeReadNeverTakesItsProjectForGoneNorMakesASecondMain()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var mainRecord = File.ReadAllText(folder.ProjectRecordPath(main.Id));
var verticalRecord = File.ReadAllText(folder.ProjectRecordPath(vertical.Id));
// Main's record as a newer Chronos writes it, Vertical's damaged.
var newer = mainRecord.Replace("\"formatVersion\": 1", "\"formatVersion\": 2", StringComparison.Ordinal);
File.WriteAllText(folder.ProjectRecordPath(main.Id), newer);
File.WriteAllText(folder.ProjectRecordPath(vertical.Id), "{ not json");
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.Equal(main.Id, (await projects.MainAsync(sequence.Id, fx.Ct)).Id);
Assert.Count(2, ProjectFolders(folder));
Assert.Null((await fx.Db.Projects.GetAsync(vertical.Id))!.DeletedAt);
// Nothing is written over a record that cannot be read: the versions sent wait.
var head = await projects.HeadAsync(vertical.Id, fx.Ct);
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => projects.PushAsync(vertical.Id, Draft(head, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct));
var home = new ArchiveProjectHome(fx.Db, projects, sequence.Id);
await Assert.ThrowsAsync<HomeUnavailableException>(() => home.PushAsync(vertical.Id, Draft(head, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct));
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => projects.RenameAsync(vertical.Id, "Square", fx.Ct));
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => projects.DeleteAsync(vertical.Id, fx.Ct));
Assert.Equal("{ not json", File.ReadAllText(folder.ProjectRecordPath(vertical.Id)));
Assert.Equal(newer, File.ReadAllText(folder.ProjectRecordPath(main.Id)));
// Readable again: everything is as it was, and goes on.
File.WriteAllText(folder.ProjectRecordPath(main.Id), mainRecord);
File.WriteAllText(folder.ProjectRecordPath(vertical.Id), verticalRecord);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, Draft(head, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Outcome);
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
// An index that meets Main's record unreadable makes no Main of its own either, and takes it once it reads.
File.WriteAllText(folder.ProjectRecordPath(main.Id), newer);
await fx.ReopenWithEmptyIndexAsync();
Assert.Empty((await fx.ScanAsync(ScanMode.Rebuild)).Failed);
var rebuilt = fx.Service.Projects;
Assert.SequenceEqual([vertical.Id], (await rebuilt.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => rebuilt.MainAsync(sequence.Id, fx.Ct));
await Assert.ThrowsAsync<HomeUnavailableException>(() => new ArchiveProjectHome(fx.Db, rebuilt, sequence.Id).ListAsync(fx.Ct));
Assert.Count(2, ProjectFolders(folder));
File.WriteAllText(folder.ProjectRecordPath(main.Id), mainRecord);
Assert.Equal(main.Id, (await rebuilt.MainAsync(sequence.Id, fx.Ct)).Id);
Assert.Equal(1, MainRecords(folder));
}
[Test]
public async Task AMissingProjectsFolderIsWrittenAgainFromTheIndex()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var pushed = (await projects.PushAsync(vertical.Id, Draft(await projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [2] }, frames),
fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Moved away for a moment (a sync tool, a backup put back without it): no project is taken for gone, none made anew.
Directory.Move(folder.ProjectsDirectory, folder.ProjectsDirectory + "-aside");
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.Equal(1, MainRecords(folder));
Assert.Equal(pushed.Id, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Head!.Id);
Assert.Equal(pushed.ContentHash, ProjectSidecars.ReadVersion(folder.VersionPath(vertical.Id, 2, pushed.Id)).ContentHash);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, Draft(pushed, new ProjectSettings(), frames), fx.Ct)).Outcome);
// The sidecars written again are the truth again: a rebuilt index has every project and version back.
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
var listed = await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct);
Assert.SequenceEqual([main.Id, vertical.Id], listed.Select(p => p.Id));
Assert.Equal(3, listed[1].HeadNumber);
}
[Test]
public async Task AMainAnOlderChronosTookForGoneIsListedAgain()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// Its live record says it is not deleted: Main again, no second one.
await fx.Db.Projects.UpdateAsync((await fx.Db.Projects.GetAsync(main.Id))! with { DeletedAt = DateTimeOffset.UtcNow });
Assert.SequenceEqual([main.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.Equal(main.Id, (await projects.MainAsync(sequence.Id, fx.Ct)).Id);
// And with its folder gone too: written again from the index.
await fx.Db.Projects.UpdateAsync((await fx.Db.Projects.GetAsync(main.Id))! with { DeletedAt = DateTimeOffset.UtcNow });
Directory.Move(folder.ProjectDirectory(main.Id), folder.ProjectDirectory(main.Id) + "-aside");
Assert.SequenceEqual([main.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.True(ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id)).IsMain);
Assert.Equal(1, MainRecords(folder));
}
[Test]
public async Task ASecondIndexMeetingMainBetweenTwoPushesRevertsNothing()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var second = (await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct),
new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } }, frames), fx.Ct)).Version!;
// Another PC indexes the archive (its copy of the settings: version 2's), then this one pushes version 3.
var (other, _) = await fx.OtherWriterAsync();
var third = (await projects.PushAsync(main.Id, Draft(second, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 1.4 } }, frames),
fx.Ct)).Version!;
// Its first look takes the settings from the archive, not from its old copy: no version is added.
await other.Projects.ListAsync(sequence.Id, fx.Ct);
Assert.SequenceEqual([3, 2, 1], (await other.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.Equal(1.4, Settings(fx, sequence).Exposure.ExposureOffsetEv);
Assert.Equal(third.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Equal(1.4, ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!).Exposure.ExposureOffsetEv);
}
[Test]
public async Task AnIndexWithAnOldCopyOfTheSettingsBringsItUpToMain()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [0] }, frames),
fx.Ct)).Version!;
// An index taken back from a backup made before: it holds the sequence with the settings it had then, and no projects.
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync();
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { ExcludedFrames = [1] });
var listed = await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct);
Assert.Equal((pushed.Id, 2), (listed[0].HeadVersionId, listed[0].HeadNumber));
Assert.SequenceEqual([2, 1], (await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.SequenceEqual([0], ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!).ExcludedFrames);
Assert.SequenceEqual([0], Settings(fx, sequence).ExcludedFrames);
}
[Test]
public async Task AMirrorACrashCutShortBeforeProjectJsonIsCompletedAfterARebuild()
{
foreach (var olderRecord in new[] { false, true })
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
await projects.PushAsync(main.Id, Draft(first, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.Median } }, frames), fx.Ct);
// As if the push had stopped before its mirror wrote project.json (an older record names no mirror at all).
var folder = fx.Paths.Sequence(sequence.Folder);
File.WriteAllText(folder.ProjectPath, ProjectSettings.FromJson(ProjectContent.Place(first.SettingsJson, Photos(frames))).ToJson());
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Mirrored = olderRecord ? null : new ProjectHead(first.Id, 1) });
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.SequenceEqual([2, 1], (await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.Equal(StackSetting.Median, Settings(fx, sequence).Stack.Mode);
Assert.Equal(StackSetting.Median, ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!).Stack.Mode);
}
}
[Test]
public async Task SettingsAnOlderChronosWroteIntoProjectJsonBecomeAnExternalVersionForAnIndexMeetingMain()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } },
frames), fx.Ct);
// An older Chronos on another PC edits the sequence (project.json); this PC's index is then rebuilt.
File.WriteAllText(fx.Paths.Sequence(sequence.Folder).ProjectPath, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = -1 } }.ToJson());
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
var history = await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([3, 2, 1], history.Select(v => v.Number));
Assert.Equal(ProjectVersionKind.External, history[0].Kind);
Assert.Equal(-1, ProjectSettings.FromJson(history[0].SettingsJson).Exposure.ExposureOffsetEv);
}
[Test]
public async Task AMainHeadOfANewerChronosIsListedAndPulledButNeverMirroredNorBuiltOn()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var head = await projects.HeadAsync(main.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// A newer Chronos on another PC sharing the archive pushes version 2 in its settings format, and mirrors it.
var settings = """{ "version": 2, "exposure": { "exposureOffsetEv": 0.5 }, "futureThing": true }""";
var now = DateTimeOffset.UtcNow;
var future = new ProjectVersion
{
Id = Guid.CreateVersion7(),
ProjectId = main.Id,
ParentId = head.Id,
Number = 2,
Kind = ProjectVersionKind.Commit,
ClientName = "newer",
SettingsJson = settings,
ContentHash = ProjectContent.Hash(settings),
SettingsFormat = 2,
FramesVersion = head.FramesVersion,
CreatedAt = now,
StoredAt = now,
};
ProjectSidecars.WriteVersion(folder.VersionPath(main.Id, 2, future.Id), future);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Head = new ProjectHead(future.Id, 2), Mirrored = new ProjectHead(future.Id, 2) });
File.WriteAllText(folder.ProjectPath, settings);
var copy = (await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson;
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.Equal(future.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Equal(future.Id, (await new ArchiveProjectHome(fx.Db, projects, sequence.Id).VersionsAfterAsync(main.Id, 1, 10, fx.Ct)).Single().Id);
Assert.Equal(PushOutcome.Stored,
(await projects.PushAsync(vertical.Id, Draft(await projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Outcome);
Assert.Count(2, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
Assert.Equal(settings, File.ReadAllText(folder.ProjectPath));
Assert.Equal(copy, (await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson);
// An older path writes the settings here meanwhile: nothing is merged into, or added over, the newer head.
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { ExcludedFrames = [2] });
await projects.ListAsync(sequence.Id, fx.Ct);
await projects.ListAsync(sequence.Id, fx.Ct);
Assert.Count(2, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
Assert.Equal(settings, File.ReadAllText(folder.ProjectPath));
// Nor by an index meeting it for the first time.
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.Equal(future.Id, (await fx.Service.Projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Count(2, await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
Assert.Equal(settings, File.ReadAllText(folder.ProjectPath));
}
[Test]
public async Task APushThisChronosCannotReadStrictlyIsRefused()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var head = await projects.HeadAsync(main.Id, fx.Ct);
var wrong = """{ "exposure": 5 }""";
var result = await projects.PushAsync(main.Id, Draft(head, new ProjectSettings(), frames) with { SettingsJson = wrong, ContentHash = ProjectContent.Hash(wrong) },
fx.Ct);
Assert.Equal(PushOutcome.Invalid, result.Outcome);
Assert.Count(1, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(main.Id, Draft(head, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Outcome);
}
[Test]
public async Task AHeadThisChronosCannotReadLeavesTheRecordAndTheHistoryUntouched()
{
foreach (var missing in new[] { false, true })
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var second = (await projects.PushAsync(main.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Version 2's file in a newer Chronos's format, or not here yet (a sync tool that brought the record first).
var path = folder.VersionPath(main.Id, 2, second.Id);
var text = File.ReadAllText(path);
if (missing) File.Delete(path);
else File.WriteAllText(path, text.Replace("\"formatVersion\": 1", "\"formatVersion\": 2", StringComparison.Ordinal));
var recordBytes = File.ReadAllBytes(folder.ProjectRecordPath(main.Id));
await fx.ReopenWithEmptyIndexAsync();
Assert.Empty((await fx.ScanAsync(ScanMode.Rebuild)).Failed);
var rebuilt = fx.Service.Projects;
var listed = await rebuilt.ListAsync(sequence.Id, fx.Ct);
Assert.Equal((main.Id, first.Id), (listed.Single().Id, listed.Single().HeadVersionId));
Assert.Equal(first.Id, (await rebuilt.HeadAsync(main.Id, fx.Ct)).Id);
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => rebuilt.PushAsync(main.Id, Draft(first, new ProjectSettings(), frames), fx.Ct));
Assert.SequenceEqual(recordBytes, File.ReadAllBytes(folder.ProjectRecordPath(main.Id)));
Assert.False(Directory.Exists(Path.Combine(folder.ProjectVersionsDirectory(main.Id), ".stray")));
Assert.Count(missing ? 1 : 2, ProjectSidecars.ListVersions(folder.ProjectVersionsDirectory(main.Id)));
Assert.Empty((await fx.ScanAsync(ScanMode.Rebuild)).Failed);
// Once it reads, the history goes on from it.
File.WriteAllText(path, text);
Assert.Equal(second.Id, (await rebuilt.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Equal(PushOutcome.Stored, (await rebuilt.PushAsync(main.Id, Draft(second, new ProjectSettings(), frames), fx.Ct)).Outcome);
}
}
[Test]
public async Task VersionFilesOfOneNumberAndRecordsThatAllSayMainNeverStopARebuild()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var other = (await UploadedAsync(fx, 1, seed: 300)).Sequence;
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var otherMain = await projects.MainAsync(other.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var second = (await projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Another file numbered 2, off the record's chain, and two more records that say they are Main and are named so.
var twin = Draft(first, new ProjectSettings { ExcludedFrames = [0] }, frames) with { StoredAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 2, twin.Id), twin);
foreach (var _ in new[] { 1, 2 })
{
var id = Guid.CreateVersion7();
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(id), new ProjectRecord(id, sequence.Id, ProjectService.MainName, true, null, DateTimeOffset.UtcNow, null,
DateTimeOffset.UtcNow));
}
await fx.ReopenWithEmptyIndexAsync();
Assert.Empty((await fx.ScanAsync(ScanMode.Rebuild)).Failed);
var listed = await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct);
Assert.Equal(main.Id, listed.Single(p => p.IsMain).Id);
Assert.SequenceEqual(["Main", "Main (2)", "Main (3)", "Vertical"], listed.Select(p => p.Name).Order(StringComparer.Ordinal));
Assert.Equal(second.Id, listed.Single(p => p.Id == vertical.Id).HeadVersionId);
Assert.Count(1, Directory.GetFiles(Path.Combine(folder.ProjectVersionsDirectory(vertical.Id), ".stray")));
Assert.NotNull(await fx.Db.Projects.GetAsync(otherMain.Id));
}
[Test]
public async Task ALargeVersionIsStoredAndReadBackAndOneTooLargeIsNeverStored()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var head = await projects.HeadAsync(vertical.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// Some 30,000 photos parked by a long sequence (its nights excluded): past the old 8 MB read limit.
var pending = Enumerable.Range(0, 30_000).Select(i => new PendingFrame
{
Sha256 = Convert.ToHexStringLower(SHA256.HashData(BitConverter.GetBytes(i))),
Size = 1_000_000 + i,
CapturedAt = Start.AddSeconds(i),
Excluded = true,
}).ToList();
var settings = ProjectContent.Canonical(new ProjectSettings { PendingFrames = pending }.ToJson());
var large = Draft(head, new ProjectSettings(), frames) with { SettingsJson = settings, ContentHash = ProjectContent.Hash(settings) };
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, large, fx.Ct)).Outcome);
var path = folder.VersionPath(vertical.Id, 2, large.Id);
Assert.Greater(new FileInfo(path).Length, 8L << 20);
Assert.Equal(large.ContentHash, ProjectSidecars.ReadVersion(path).ContentHash);
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
var rebuilt = fx.Service.Projects;
Assert.Equal(large.Id, (await rebuilt.HeadAsync(vertical.Id, fx.Ct)).Id);
// One whose file would be past the limit is refused, and nothing is written.
var huge = Draft(large, new ProjectSettings(), frames) with { Note = new string('x', ProjectSidecars.MaxVersionBytes) };
Assert.Equal(PushOutcome.TooLarge, (await rebuilt.PushAsync(vertical.Id, huge, fx.Ct)).Outcome);
Assert.False(File.Exists(folder.VersionPath(vertical.Id, 3, huge.Id)));
Assert.Throws<ProjectVersionTooLargeException>(() => ProjectSidecars.WriteVersion(Path.Combine(Context.CreateTempDirectory("huge"), "v.json"), huge));
}
[Test]
public async Task TheHomeHoldsAVersionOnlyWhileItsFileReadsBack()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var second = (await projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
IProjectHome home = new ArchiveProjectHome(fx.Db, projects, sequence.Id);
Assert.True(await home.HoldsAsync(vertical.Id, first, fx.Ct));
Assert.True(await home.HoldsAsync(vertical.Id, second, fx.Ct));
Assert.False(await home.HoldsAsync(vertical.Id, second with { ContentHash = new string('0', 64) }, fx.Ct));
// The index still has both rows, but the archive no longer holds them as they were.
File.WriteAllText(folder.VersionPath(vertical.Id, 1, first.Id), "damaged");
File.Delete(folder.VersionPath(vertical.Id, 2, second.Id));
Assert.NotNull(await home.GetVersionAsync(vertical.Id, first.Id, fx.Ct));
Assert.False(await home.HoldsAsync(vertical.Id, first, fx.Ct));
Assert.False(await home.HoldsAsync(vertical.Id, second, fx.Ct));
}
[Test]
public async Task ADeleteThatCannotMoveTheFolderChangesNothing()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// The projects' trash cannot take the folder (a file in its way): the delete fails and says so, and nothing changed.
File.WriteAllText(folder.ProjectsTrashDirectory, "in the way");
await Assert.ThrowsAsync<IOException>(() => projects.DeleteAsync(vertical.Id, fx.Ct));
Assert.Null(ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Deleted);
Assert.SequenceEqual(["Main", "Vertical"], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Name));
File.Delete(folder.ProjectsTrashDirectory);
await projects.DeleteAsync(vertical.Id, fx.Ct);
Assert.False(Directory.Exists(folder.ProjectDirectory(vertical.Id)));
Assert.NotNull(ProjectSidecars.ReadRecord(Path.Combine(Directory.GetDirectories(folder.ProjectsTrashDirectory).Single(), "project.json")).Deleted);
Assert.SequenceEqual(["Main"], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Name));
}
[Test]
public async Task ASequenceOfAReadOnlyArchiveOpensFromItsSidecarsWithoutWriting()
{
var fx = await FixtureAsync();
var (fresh, freshFrames) = await UploadedAsync(fx, 2);
var (edited, frames) = await UploadedAsync(fx, 2, seed: 300);
var vertical = await fx.Service.Projects.CreateAsync(edited.Id, "Vertical", cancellationToken: fx.Ct);
var pushed = (await fx.Service.Projects.PushAsync(vertical.Id,
Draft(await fx.Service.Projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync();
var projects = fx.Service.Projects;
projects.Availability = _ => ArchiveAvailability.ReadOnly;
var locks = Directory.Exists(fx.Paths.LocksDirectory) ? Directory.GetFiles(fx.Paths.LocksDirectory).Length : 0;
// A sequence with projects: read from its sidecars as they are.
var home = new ArchiveProjectHome(fx.Db, projects, edited.Id);
Assert.SequenceEqual(["Main", "Vertical"], (await home.ListAsync(fx.Ct)).Select(p => p.Name));
Assert.Equal(pushed.Id, (await home.HeadAsync(vertical.Id, fx.Ct)).Id);
await Assert.ThrowsAsync<HomeUnavailableException>(() => home.PushAsync(vertical.Id, Draft(pushed, new ProjectSettings(), frames), fx.Ct));
// A sequence with none yet: a Main in the index only, nothing written to the archive.
var freshHome = new ArchiveProjectHome(fx.Db, projects, fresh.Id);
var main = (await freshHome.ListAsync(fx.Ct)).Single();
Assert.True(main.IsMain);
var head = await freshHome.HeadAsync(main.Id, fx.Ct);
Assert.False(Directory.Exists(fx.Paths.Sequence(fresh.Folder).ProjectsDirectory));
Assert.Equal(locks, Directory.Exists(fx.Paths.LocksDirectory) ? Directory.GetFiles(fx.Paths.LocksDirectory).Length : 0);
await Assert.ThrowsAsync<HomeUnavailableException>(() => freshHome.PushAsync(main.Id, Draft(head, new ProjectSettings(), freshFrames), fx.Ct));
// Once the archive takes writes, that Main's sidecars are written, under the same id, and it goes on.
projects.Availability = ArchiveVolume.Probe;
Assert.Equal(main.Id, (await freshHome.ListAsync(fx.Ct)).Single().Id);
var folder = fx.Paths.Sequence(fresh.Folder);
Assert.Equal((main.Id, true), (ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id)).Id, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id)).IsMain));
Assert.FileExists(folder.VersionPath(main.Id, 1, head.Id));
Assert.Equal(PushOutcome.Stored, (await freshHome.PushAsync(main.Id, Draft(head, new ProjectSettings { ExcludedFrames = [0] }, freshFrames), fx.Ct)).Outcome);
}
[Test]
public async Task AnIndexOnlyMainMeetingAMainAnotherIndexMadeIsWrittenBackAsAnotherProject()
{
var fx = await FixtureAsync();
var (fresh, frames) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
projects.Availability = _ => ArchiveAvailability.ReadOnly;
var ours = (await projects.ListAsync(fresh.Id, fx.Ct)).Single();
// Meanwhile another PC's index makes its own Main into the archive; then this archive takes writes again.
var (other, _) = await fx.OtherWriterAsync();
var theirs = await other.Projects.MainAsync(fresh.Id, fx.Ct);
projects.Availability = ArchiveVolume.Probe;
// Theirs is Main, ours another project: in the index and in the sidecars alike, and it stays so.
foreach (var _ in new[] { 1, 2 })
{
Assert.SequenceEqual([(theirs.Id, "Main", true), (ours.Id, "Main (2)", false)],
(await projects.ListAsync(fresh.Id, fx.Ct)).Select(p => (p.Id, p.Name, p.IsMain)));
}
var folder = fx.Paths.Sequence(fresh.Folder);
Assert.Equal(1, MainRecords(folder));
var ourRecord = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(ours.Id));
Assert.Equal(("Main (2)", false), (ourRecord.Name, ourRecord.IsMain));
Assert.Equal(theirs.Id, (await other.Projects.MainAsync(fresh.Id, fx.Ct)).Id);
Assert.SequenceEqual([theirs.Id, ours.Id], (await other.Projects.ListAsync(fresh.Id, fx.Ct)).Select(p => p.Id));
Assert.Equal(PushOutcome.Stored,
(await projects.PushAsync(theirs.Id, Draft(await projects.HeadAsync(theirs.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Outcome);
Assert.SequenceEqual([1], Settings(fx, fresh).ExcludedFrames);
}
[Test]
public async Task AMainAnotherIndexPassedOnIsTakenFromTheRecords()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var second = await projects.CreateAsync(sequence.Id, "Main (2)", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// Another index passed Main on, names and all: the records say the opposite of this index.
var mainRecord = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
var secondRecord = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(second.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), mainRecord with { IsMain = false, Name = "Main (2)", Mirrored = null });
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(second.Id), secondRecord with { IsMain = true, Name = "Main" });
Assert.SequenceEqual([(second.Id, "Main", true), (main.Id, "Main (2)", false)],
(await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => (p.Id, p.Name, p.IsMain)));
Assert.Equal(second.Id, (await projects.MainAsync(sequence.Id, fx.Ct)).Id);
Assert.Count(1, (await fx.Db.Projects.ListBySequenceAsync(sequence.Id, includeDeleted: true, fx.Ct)).Where(p => p.IsMain));
Assert.Equal(1, MainRecords(folder));
}
[Test]
public async Task AProjectCreationCutBeforeItsRecordHoldsNothingBack()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 2);
var folder = fx.Paths.Sequence(sequence.Folder);
// As making Main leaves it when its record cannot be written after its version (a lost disk, a crash): a folder with
// version 1 and no record, of a project no index row names.
var id = Guid.CreateVersion7();
var settings = ProjectContent.ToPortable(new ProjectSettings(), Photos(frames));
var now = DateTimeOffset.UtcNow;
var cut = new ProjectVersion
{
Id = Guid.CreateVersion7(),
ProjectId = id,
Number = 1,
Kind = ProjectVersionKind.Imported,
ClientName = "cut",
SettingsJson = settings,
ContentHash = ProjectContent.Hash(settings),
SettingsFormat = ProjectContent.FormatOf(settings),
FramesVersion = sequence.FramesVersion,
CreatedAt = now,
StoredAt = now,
};
ProjectSidecars.WriteVersion(folder.VersionPath(id, 1, cut.Id), cut);
var main = await fx.Service.Projects.MainAsync(sequence.Id, fx.Ct);
Assert.NotEqual(id, main.Id);
Assert.SequenceEqual([main.Id], (await new ArchiveProjectHome(fx.Db, fx.Service.Projects, sequence.Id).ListAsync(fx.Ct)).Select(p => p.Id));
Assert.FileExists(folder.VersionPath(id, 1, cut.Id));
Assert.Null(await fx.Db.Projects.GetAsync(id));
// Its record there at last (a sync tool bringing another PC's Main, made before this one): Main, as in every index; the
// one made here meanwhile is another project, its version kept.
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(id), new ProjectRecord(id, sequence.Id, ProjectService.MainName, true, new ProjectHead(cut.Id, 1), now, null, now));
Assert.SequenceEqual([(id, "Main", true), (main.Id, "Main (2)", false)],
(await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => (p.Id, p.Name, p.IsMain)));
Assert.Equal(1, MainRecords(folder));
Assert.Count(1, await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
}
[Test]
public async Task AMainMadeWhileAnotherMainsRecordWasNotThereYetGivesWayInEveryIndex()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct))
.Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Another PC's index meets the sequence while a sync tool is still bringing Main's record: it makes a Main of its own.
var record = folder.ProjectRecordPath(main.Id);
File.Move(record, record + ".syncing");
var (other, _) = await fx.OtherWriterAsync();
var theirs = await other.Projects.MainAsync(sequence.Id, fx.Ct);
Assert.NotEqual(main.Id, theirs.Id);
File.Move(record + ".syncing", record);
// The record there, both indexes take the older Main, in either order, and the other is an ordinary project with its version.
foreach (var service in new[] { other, fx.Service, other })
{
Assert.SequenceEqual([(main.Id, "Main", true), (theirs.Id, "Main (2)", false)],
(await service.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => (p.Id, p.Name, p.IsMain)));
}
Assert.Equal(1, MainRecords(folder));
Assert.Equal(("Main (2)", false), (ProjectSidecars.ReadRecord(folder.ProjectRecordPath(theirs.Id)).Name, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(theirs.Id)).IsMain));
Assert.Count(1, await other.Projects.HistoryAsync(theirs.Id, cancellationToken: fx.Ct));
Assert.Equal(pushed.Id, (await other.Projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Equal(PushOutcome.Stored, (await other.Projects.PushAsync(main.Id, Draft(pushed, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct)).Outcome);
Assert.SequenceEqual([2], Settings(fx, sequence).ExcludedFrames);
Assert.Equal(main.Id, (await projects.MainAsync(sequence.Id, fx.Ct)).Id);
}
[Test]
public async Task AProjectWhoseRecordIsLostIsWrittenAgainFromTheIndex()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var second = (await projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
var mainSecond = (await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct))
.Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
// Version 3 of Vertical is in its folder (another PC's push), then both records and version 1's file are lost.
var third = Draft(second, new ProjectSettings { ExcludedFrames = [0] }, frames) with { StoredAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 3, third.Id), third);
File.Delete(folder.ProjectRecordPath(vertical.Id));
File.Delete(folder.ProjectRecordPath(main.Id));
File.Delete(folder.VersionPath(vertical.Id, 1, first.Id));
// The first look holds them back and writes nothing (a sync tool may still be bringing the records); once the folders
// looked the same twice, nothing is held back: the records are written again from the index, the version on disk past
// its head adopted.
projects.RecordSettle = TimeSpan.Zero;
Assert.SequenceEqual([(main.Id, true, 2), (vertical.Id, false, 2)],
(await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => (p.Id, p.IsMain, p.HeadNumber)));
Assert.False(File.Exists(folder.ProjectRecordPath(vertical.Id)));
Assert.False(File.Exists(folder.ProjectRecordPath(main.Id)));
Assert.SequenceEqual([(main.Id, true, 2), (vertical.Id, false, 3)],
(await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => (p.Id, p.IsMain, p.HeadNumber)));
var verticalRecord = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
Assert.Equal(("Vertical", third.Id), (verticalRecord.Name, verticalRecord.Head!.Id));
var mainRecord = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
Assert.Equal((true, mainSecond.Id, mainSecond.Id), (mainRecord.IsMain, mainRecord.Head!.Id, mainRecord.Mirrored?.Id));
Assert.FileExists(folder.VersionPath(vertical.Id, 1, first.Id));
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(main.Id, Draft(mainSecond, new ProjectSettings { ExcludedFrames = [0] }, frames), fx.Ct)).Outcome);
Assert.SequenceEqual([0], Settings(fx, sequence).ExcludedFrames);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, Draft(third, new ProjectSettings(), frames), fx.Ct)).Outcome);
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.SequenceEqual([4, 3, 2, 1], (await fx.Service.Projects.HistoryAsync(vertical.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.SequenceEqual([3, 2, 1], (await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
}
[Test]
public async Task ARenameMadeAfterABackupStaysWhenTheBackupIsPutBack()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var backup = folder.ProjectsDirectory + "-backup";
CopyDirectory(folder.ProjectsDirectory, backup);
await projects.PushAsync(vertical.Id, Draft(await projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct);
await projects.RenameAsync(vertical.Id, "Square", fx.Ct);
// The backup made before is put back: its record is behind the index and names the old name.
Directory.Delete(folder.ProjectsDirectory, recursive: true);
CopyDirectory(backup, folder.ProjectsDirectory);
Assert.Equal("Square", (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
Assert.Equal(("Square", 2), (record.Name, record.Head!.Number));
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.Equal("Square", (await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
}
[Test]
public async Task ARenameOnlyMadeAfterABackupStaysWhenTheBackupIsPutBack()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var backup = folder.ProjectsDirectory + "-backup";
CopyDirectory(folder.ProjectsDirectory, backup);
await projects.RenameAsync(vertical.Id, "Square", fx.Ct);
// The backup made before the rename (the same head) is put back: its record was written before the index's name.
Directory.Delete(folder.ProjectsDirectory, recursive: true);
CopyDirectory(backup, folder.ProjectsDirectory);
Assert.Equal("Square", (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
Assert.Equal(("Square", 1), (record.Name, record.Head!.Number));
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.Equal("Square", (await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
// A rename another PC makes is newer than what this index knows, even from a clock behind the one this index wrote
// with (ten minutes ahead here): it is taken.
var (other, _) = await fx.OtherWriterAsync();
Assert.Equal("Square", (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
var ahead = DateTimeOffset.UtcNow.AddMinutes(10);
var written = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(vertical.Id), written with { Updated = ahead });
await fx.Db.Projects.UpdateAsync((await fx.Db.Projects.GetAsync(vertical.Id))! with { UpdatedAt = ahead }, fx.Ct);
await other.Projects.RenameAsync(vertical.Id, "Wide", fx.Ct);
Assert.True(ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Updated > ahead);
Assert.Equal("Wide", (await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
Assert.Equal("Wide", ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Name);
}
[Test]
public async Task ARecordOnAnotherChainBelowTheHeadKeepsItsName()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var second = (await projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
await projects.PushAsync(vertical.Id, Draft(second, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// Another PC's record, on a chain of its own from version 1, renamed there: its head number is below the index's, but
// it is not a version the index holds, so the record is not behind and its name is taken.
var theirs = Draft(first, new ProjectSettings { ExcludedFrames = [0] }, frames) with { StoredAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 2, theirs.Id), theirs);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
var apart = record with { Name = "Square", Head = new ProjectHead(theirs.Id, 2), Updated = DateTimeOffset.UtcNow.AddSeconds(1) };
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(vertical.Id), apart);
var listed = (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id);
Assert.Equal(("Square", 3), (listed.Name, listed.HeadNumber));
// Index and record agree on the name, and the record is never written over.
Assert.Equal(apart, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)));
Assert.Equal("Square", (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
}
[Test]
public async Task ADeletionArrivingHalfSyncedIsTakenAndNeverUndone()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var square = await projects.CreateAsync(sequence.Id, "Square", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var (other, _) = await fx.OtherWriterAsync();
Assert.SequenceEqual([main.Id, vertical.Id, square.Id], (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
projects.RecordSettle = TimeSpan.Zero;
other.Projects.RecordSettle = TimeSpan.Zero;
// This PC deletes Vertical; on the other PC a sync tool moving it file by file into the trash has left its live folder
// with a version file and no record. However often the other index looks, it takes the deletion and writes nothing.
await projects.DeleteAsync(vertical.Id, fx.Ct);
var trashed = Directory.GetDirectories(folder.ProjectsTrashDirectory).Single();
Directory.CreateDirectory(folder.ProjectVersionsDirectory(vertical.Id));
foreach (var file in Directory.GetFiles(Path.Combine(trashed, ArchiveLayout.ProjectVersionsFolder)))
File.Copy(file, Path.Combine(folder.ProjectVersionsDirectory(vertical.Id), Path.GetFileName(file)));
for (var i = 0; i < 2; i++)
{
Assert.SequenceEqual([main.Id, square.Id], (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.SequenceEqual([main.Id, square.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
}
Assert.NotNull((await other.Projects.GetAsync(vertical.Id, fx.Ct))!.DeletedAt);
Assert.False(File.Exists(folder.ProjectRecordPath(vertical.Id)));
// Square's deletion arrives with its versions in the trash before its record, and its live record gone already: it is
// held back (listed, nothing written), never written again as live, and deleted once the trash's record is there.
var squareTrash = Path.Combine(folder.ProjectsTrashDirectory, square.Id.ToString("N") + "-" + DateTimeOffset.UtcNow.UtcTicks);
CopyDirectory(folder.ProjectDirectory(square.Id), squareTrash);
var squareRecord = ProjectSidecars.ReadRecord(Path.Combine(squareTrash, ArchiveLayout.ProjectFile));
File.Delete(Path.Combine(squareTrash, ArchiveLayout.ProjectFile));
File.Delete(folder.ProjectRecordPath(square.Id));
for (var i = 0; i < 2; i++)
Assert.SequenceEqual([main.Id, square.Id], (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.False(File.Exists(folder.ProjectRecordPath(square.Id)));
ProjectSidecars.WriteRecord(Path.Combine(squareTrash, ArchiveLayout.ProjectFile), squareRecord with { Deleted = DateTimeOffset.UtcNow });
Assert.SequenceEqual([main.Id], (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.SequenceEqual([main.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.False(File.Exists(folder.ProjectRecordPath(square.Id)));
// A rebuilt index has both deleted too.
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.SequenceEqual([main.Id], (await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
}
[Test]
public async Task APushMadeIntoTheLiveFolderBeforeADeletionArrivedIsKeptBesideTheDeletedRecord()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var (other, _) = await fx.OtherWriterAsync();
var before = folder.ProjectsDirectory + "-before";
CopyDirectory(folder.ProjectDirectory(vertical.Id), before);
await projects.DeleteAsync(vertical.Id, fx.Ct);
// The other PC pushed version 2 into its live folder before the deletion reached it: a sync tool brings that folder
// back beside the trash. The deletion wins, and version 2 goes beside the deleted record, never left where nothing reads it.
CopyDirectory(before, folder.ProjectDirectory(vertical.Id));
var theirs = Draft(first, new ProjectSettings { ExcludedFrames = [2] }, frames) with { StoredAt = DateTimeOffset.UtcNow };
var pushed = folder.VersionPath(vertical.Id, 2, theirs.Id);
ProjectSidecars.WriteVersion(pushed, theirs);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(vertical.Id), record with { Head = new ProjectHead(theirs.Id, 2), Updated = DateTimeOffset.UtcNow });
Assert.SequenceEqual([main.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
var trashed = Directory.GetDirectories(folder.ProjectsTrashDirectory).Single();
var kept = Path.Combine(trashed, ArchiveLayout.ProjectVersionsFolder, Path.GetFileName(pushed));
Assert.FileExists(kept);
Assert.FileMissing(pushed);
Assert.Equal(theirs.Id, ProjectSidecars.ReadVersion(kept).Id);
Assert.FileExists(Path.Combine(trashed, ArchiveLayout.ProjectVersionsFolder, Path.GetFileName(folder.VersionPath(vertical.Id, 1, first.Id))));
Assert.NotNull(ProjectSidecars.ReadRecord(Path.Combine(trashed, ArchiveLayout.ProjectFile)).Deleted);
Assert.SequenceEqual([main.Id], (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.SequenceEqual([main.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
}
[Test]
public async Task ATrashFolderOfAnotherSequenceOrLongWithoutARecordNoLongerHoldsBackALostRecord()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
projects.RecordSettle = TimeSpan.Zero;
var path = folder.ProjectRecordPath(vertical.Id);
var lost = ProjectSidecars.ReadRecord(path);
// A folder of the projects' trash with no record, just made (a deletion on its way): the lost record is not written.
var leftover = Path.Combine(folder.ProjectsTrashDirectory, vertical.Id.ToString("N") + "-1");
Directory.CreateDirectory(leftover);
File.Delete(path);
for (var i = 0; i < 2; i++) await projects.ListAsync(sequence.Id, fx.Ct);
Assert.False(File.Exists(path), "held back while a deletion may be on its way");
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct));
// Nothing written in it for longer than the grace: a leftover, which holds nothing back any more.
Directory.SetLastWriteTimeUtc(leftover, DateTime.UtcNow - ProjectIndexer.TrashRecordGrace - TimeSpan.FromHours(1));
for (var i = 0; i < 2; i++) await projects.ListAsync(sequence.Id, fx.Ct);
Assert.Equal(("Vertical", first.Id), (ProjectSidecars.ReadRecord(path).Name, ProjectSidecars.ReadRecord(path).Head!.Id));
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Outcome);
Directory.Delete(leftover);
// A trash folder whose record names another sequence (a sequence folder copied by hand): never this one's deletion.
var foreign = Path.Combine(folder.ProjectsTrashDirectory, vertical.Id.ToString("N") + "-2");
Directory.CreateDirectory(foreign);
ProjectSidecars.WriteRecord(Path.Combine(foreign, ArchiveLayout.ProjectFile), lost with { SequenceId = Guid.CreateVersion7(), Deleted = DateTimeOffset.UtcNow });
File.Delete(path);
for (var i = 0; i < 2; i++) await projects.ListAsync(sequence.Id, fx.Ct);
Assert.FileExists(path);
Assert.Contains(vertical.Id, (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
// One whose record names this sequence is its deletion.
Assert.True(ProjectIndexer.DeletionOnItsWay(foreign, vertical.Id, sequence.Id, DateTime.UtcNow) == false);
ProjectSidecars.WriteRecord(Path.Combine(foreign, ArchiveLayout.ProjectFile), lost with { Deleted = DateTimeOffset.UtcNow });
Assert.True(ProjectIndexer.DeletionOnItsWay(foreign, vertical.Id, sequence.Id, DateTime.UtcNow));
}
[Test]
public async Task AFolderWithNoRecordThatWentAndCameBackSettlesAgainFromWhenItCameBack()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 3);
var vertical = await fx.Service.Projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var settle = TimeSpan.FromMilliseconds(TestTiming.Budget(400));
var indexer = new ProjectIndexer(fx.Db) { RecordSettle = settle };
var path = folder.ProjectRecordPath(vertical.Id);
File.Delete(path);
Assert.Contains(vertical.Id, (await indexer.ReconcileAsync(folder, sequence.Id, fx.Ct)).HeldBack);
// The folder goes for a while (a sync tool moving it): what was seen of it is forgotten, so once it is back it must
// look the same for a settling time again before its record is written from the index.
var away = folder.ProjectsDirectory + "-away";
Directory.Move(folder.ProjectDirectory(vertical.Id), away);
Assert.False((await indexer.ReconcileAsync(folder, sequence.Id, fx.Ct)).Seen.Contains(vertical.Id));
await Task.Delay(settle * 2, fx.Ct);
Directory.Move(away, folder.ProjectDirectory(vertical.Id));
Assert.Contains(vertical.Id, (await indexer.ReconcileAsync(folder, sequence.Id, fx.Ct)).HeldBack);
Assert.False(File.Exists(path), "not written at once on what was seen before it went");
await Task.Delay(settle * 2, fx.Ct);
Assert.False((await indexer.ReconcileAsync(folder, sequence.Id, fx.Ct)).HeldBack.Contains(vertical.Id));
Assert.FileExists(path);
}
[Test]
public async Task AHealedRecordIsStampedPastWhatTheIndexKnowsSoTheNextRenameIsTaken()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var backup = folder.ProjectsDirectory + "-backup";
CopyDirectory(folder.ProjectsDirectory, backup);
await projects.PushAsync(vertical.Id, Draft(await projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct);
// A PC whose clock is ten minutes ahead renames it: this index takes the name and that time.
var ahead = DateTimeOffset.UtcNow.AddMinutes(10);
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(vertical.Id), ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)) with { Name = "Square", Updated = ahead });
Assert.Equal("Square", (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
// The backup is put back (behind): healed, and stamped past what the index knows.
Directory.Delete(folder.ProjectsDirectory, recursive: true);
CopyDirectory(backup, folder.ProjectsDirectory);
await projects.CreateAsync(sequence.Id, "Other", cancellationToken: fx.Ct);
var healed = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id));
Assert.Equal(("Square", 2), (healed.Name, healed.Head!.Number));
Assert.True(healed.Updated > ahead, "past the time the index took");
// Another PC with a right clock renames it: every index takes it, and nothing writes the old name back.
var (other, _) = await fx.OtherWriterAsync();
Assert.Equal("Square", (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
await other.Projects.RenameAsync(vertical.Id, "Wide", fx.Ct);
Assert.Equal("Wide", (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
await projects.CreateAsync(sequence.Id, "Other2", cancellationToken: fx.Ct);
Assert.Equal("Wide", ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Name);
Assert.Equal("Wide", (await other.Projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id).Name);
}
[Test]
public async Task ALostRecordIsWrittenAgainOnlyOnceItsFolderHasSettledSoAnIncomingOneWins()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var path = folder.ProjectRecordPath(vertical.Id);
// A sync tool is bringing the record another PC wrote (a rename, a push): meanwhile the folder holds none. However often
// the index looks within the settling time, it writes none of its own and takes nothing for the project.
var incoming = ProjectSidecars.ReadRecord(path);
File.Delete(path);
for (var i = 0; i < 2; i++)
{
var held = (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id);
Assert.Equal(("Vertical", 1), (held.Name, held.HeadNumber));
}
Assert.False(File.Exists(path));
await Assert.ThrowsAsync<ProjectsUnreadableException>(() => projects.PushAsync(vertical.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct));
// The record arrives, renamed and moved on there: it wins.
var theirs = Draft(first, new ProjectSettings { ExcludedFrames = [2] }, frames) with { StoredAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 2, theirs.Id), theirs);
ProjectSidecars.WriteRecord(path, incoming with { Name = "Square", Head = new ProjectHead(theirs.Id, 2), Updated = DateTimeOffset.UtcNow });
var listed = (await projects.ListAsync(sequence.Id, fx.Ct)).Single(p => p.Id == vertical.Id);
Assert.Equal(("Square", theirs.Id), (listed.Name, listed.HeadVersionId));
// A record really lost is written again from the index once the folder looked the same on two reconciles a settling time apart.
File.Delete(path);
projects.RecordSettle = TimeSpan.Zero;
await projects.ListAsync(sequence.Id, fx.Ct);
Assert.False(File.Exists(path));
await projects.ListAsync(sequence.Id, fx.Ct);
var written = ProjectSidecars.ReadRecord(path);
Assert.Equal(("Square", theirs.Id), (written.Name, written.Head!.Id));
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, Draft(theirs, new ProjectSettings(), frames), fx.Ct)).Outcome);
}
[Test]
public async Task AProjectsFolderPutBackFromAnOlderBackupIsMadeWholeFromTheIndex()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
var backup = folder.ProjectsDirectory + "-backup";
CopyDirectory(folder.ProjectsDirectory, backup);
var v2 = (await projects.PushAsync(vertical.Id, Draft(await projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct))
.Version!;
var m2 = (await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct)).Version!;
// The backup made before those pushes is put back: the records name version 1, the index holds version 2.
Directory.Delete(folder.ProjectsDirectory, recursive: true);
CopyDirectory(backup, folder.ProjectsDirectory);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(vertical.Id, Draft(v2, new ProjectSettings { ExcludedFrames = [0] }, frames), fx.Ct)).Outcome);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(main.Id, Draft(m2, new ProjectSettings { ExcludedFrames = [0] }, frames), fx.Ct)).Outcome);
Assert.Equal(3, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Head!.Number);
Assert.Equal(v2.ContentHash, ProjectSidecars.ReadVersion(folder.VersionPath(vertical.Id, 2, v2.Id)).ContentHash);
Assert.Equal(m2.ContentHash, ProjectSidecars.ReadVersion(folder.VersionPath(main.Id, 2, m2.Id)).ContentHash);
// The sidecars hold every version again: a rebuilt index has them all, and nothing was added.
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
Assert.SequenceEqual([3, 2, 1], (await fx.Service.Projects.HistoryAsync(vertical.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.SequenceEqual([ProjectVersionKind.Commit, ProjectVersionKind.Commit, ProjectVersionKind.Imported],
(await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Kind));
Assert.SequenceEqual([0], Settings(fx, sequence).ExcludedFrames);
// A read alone makes the records whole too.
Directory.Delete(folder.ProjectsDirectory, recursive: true);
CopyDirectory(backup, folder.ProjectsDirectory);
await fx.Service.Projects.ListAsync(sequence.Id, fx.Ct);
Assert.Equal(3, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Head!.Number);
Assert.Count(3, ProjectSidecars.ListVersions(folder.ProjectVersionsDirectory(main.Id)));
}
[Test]
public async Task AMirrorRecordThatLagsProjectJsonNeverRevertsANewerPush()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var second = (await projects.PushAsync(main.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
var folder = fx.Paths.Sequence(sequence.Folder);
var afterSecond = File.ReadAllText(folder.ProjectPath);
await projects.PushAsync(main.Id, Draft(second, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct);
// Version 2's mirror wrote project.json but not the record, and version 3's mirror was cut before project.json.
File.WriteAllText(folder.ProjectPath, afterSecond);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Mirrored = new ProjectHead(first.Id, 1) });
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
// The mirror completes: no external version brings version 2 back over version 3.
Assert.SequenceEqual([3, 2, 1], (await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.SequenceEqual([2], Settings(fx, sequence).ExcludedFrames);
}
[Test]
public async Task AnIndexMeetingMainMergesSettingsWrittenSinceWithAPushNoMirrorWrote()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, Draft(first, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.Median } }, frames), fx.Ct))
.Version!;
// Version 2's mirror cut short (the record names version 1), and an older Chronos then writes an offset into project.json.
var folder = fx.Paths.Sequence(sequence.Folder);
File.WriteAllText(folder.ProjectPath, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = -1 } }.ToJson());
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
ProjectSidecars.WriteRecord(folder.ProjectRecordPath(main.Id), record with { Mirrored = new ProjectHead(first.Id, 1) });
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
// Both are in force, as an index that knew its mirror would have merged them.
var history = await fx.Service.Projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.SequenceEqual([ProjectVersionKind.Merge, ProjectVersionKind.Commit, ProjectVersionKind.Imported], history.Select(v => v.Kind));
Assert.Equal(pushed.Id, history[0].ParentId);
Assert.Equal((StackSetting.Median, -1.0), (Settings(fx, sequence).Stack.Mode, Settings(fx, sequence).Exposure.ExposureOffsetEv));
}
[Test]
public async Task ANewerChronosHeadOverAMirrorCutShortIsLeftAsItIs()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, Draft(first, new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
// Version 2's mirror cut short, nobody writing the settings since; then a newer Chronos pushes version 3.
var reverted = await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings());
await fx.Db.Projects.SetMirroredAsync(main.Id, first.Id, reverted.SettingsVersion, fx.Ct);
var newer = NewerChronos.Push(fx, sequence, pushed);
Assert.SequenceEqual([main.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
Assert.Equal(newer.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.Count(3, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
Assert.Empty(ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!).ExcludedFrames);
}
[Test]
public async Task AProjectDeletedAtItsHomeHasNoHeadThere()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var first = await projects.HeadAsync(vertical.Id, fx.Ct);
IProjectHome home = new ArchiveProjectHome(fx.Db, projects, sequence.Id);
// Deleted (by another PC, say): a workspace asking for its head learns it is gone, never that it is in step.
await projects.DeleteAsync(vertical.Id, fx.Ct);
Assert.Equal(ProjectError.NotFound, (await Assert.ThrowsAsync<ProjectException>(() => home.HeadAsync(vertical.Id, fx.Ct))).Reason);
Assert.False(await home.HoldsAsync(vertical.Id, first, fx.Ct));
Assert.Equal(first.Id, (await home.HistoryAsync(vertical.Id, null, 10, fx.Ct)).Single().Id);
}
[Test]
public async Task AVersionParkingFortyThousandPhotosGoesFromAWorkspaceToTheArchiveAndBack()
{
var fx = await FixtureAsync();
var bed = Own(await WorkspaceFixture.CreateAsync(Context, fx, 3));
var vertical = await fx.Service.Projects.CreateAsync(bed.Sequence.Id, "Vertical", cancellationToken: fx.Ct);
var (_, sync) = bed.Workspace();
var project = await bed.CheckoutAsync(sync, vertical.Id);
// A long sequence's nights excluded: 40,000 photos parked by a version, past the old 8 MB limit of both files.
var pending = Enumerable.Range(0, 40_000).Select(i => new PendingFrame
{
Sha256 = Convert.ToHexStringLower(SHA256.HashData(BitConverter.GetBytes(i))),
Size = 1_000_000 + i,
CapturedAt = Start.AddSeconds(i),
Excluded = true,
}).ToList();
var session = await sync.OpenAsync(vertical.Id, fx.Ct);
await sync.SaveAsync(vertical.Id, session.Working with { PendingFrames = pending }, fx.Ct);
var version = Assert.NotNull(await sync.CommitAsync(vertical.Id, "nights", cancellationToken: fx.Ct));
Assert.Greater(new FileInfo(project.VersionPath(version)).Length, 8L << 20);
Assert.Equal(1, (await sync.StatusAsync(vertical.Id, bed.Home, fx.Ct)).Ahead);
var pushed = await sync.PushAsync(vertical.Id, bed.Home, fx.Ct);
Assert.Equal(version.Id, pushed.Pushed.Single().Id);
Assert.Equal(WorkspaceState.InSync, pushed.Status.State);
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
var head = await fx.Service.Projects.HeadAsync(vertical.Id, fx.Ct);
Assert.Equal((version.Id, "nights"), (head.Id, head.Note));
Assert.Count(40_000, ProjectSettings.FromJson(head.SettingsJson).PendingFrames ?? []);
}
private static void CopyDirectory(string from, string to)
{
Directory.CreateDirectory(to);
foreach (var file in Directory.GetFiles(from)) File.Copy(file, Path.Combine(to, Path.GetFileName(file)));
foreach (var directory in Directory.GetDirectories(from)) CopyDirectory(directory, Path.Combine(to, Path.GetFileName(directory)));
}
}
public sealed class SqliteProjectRecoveryTests(TestContext context) : ProjectRecoveryTests(context)
{
protected override Backend Backend => Backend.SqliteFile;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresProjectRecoveryTests(TestContext context) : ProjectRecoveryTests(context)
{
protected override Backend Backend => Backend.Postgres;
}