CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
The owner renamed the product and moved the repository to the self-hosted Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control, and asked for Actions and a first automatic release with the server package and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md). - Chronos everywhere: a byte-exact rename of contents and paths, then a per-language review of the forms the old name's ending had dictated. - Gitea instead of GitHub: the update check, licence, issue and support links read ChronosReleasesUrl; the update check takes the highest stable version, offers a pre-release build its final release and reports a repository it cannot see as a failed check. EULA, security policy and Gitea issue forms live at the repository root. - Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release, nightly image and performance gates in the .NET SDK container with git checkout and the system SQLite. The release cross-compiles the Windows programs, checks their icon, version and DPI manifest, packs installers and zips, publishes the Gitea release and pushes the server image (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows runner (WINDOWS_RUNNER). - New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the docker-exec script, which Gitea's service containers do not allow; the throw-away server runs without durability) and pe-check. - Timed tests take their budget from TestTiming (CHRONOS_TEST_TIME_FACTOR, 3 on the shared runner; the weekly performance gates keep theirs). BREAKING CHANGE: programs, settings, data folders, file types, environment variables and the Docker image use the new name; nothing is migrated from Titano, which never had a release. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
428 lines
21 KiB
C#
428 lines
21 KiB
C#
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Tests.Infrastructure;
|
|
using Chronos.Testing;
|
|
using static Chronos.Data.Tests.Archiving.ArchiveFixture;
|
|
|
|
namespace Chronos.Data.Tests.Archiving;
|
|
|
|
/// <summary>Deleting sequences into the archive's trash and restoring them (BRIEF §0.2 rule 8, §12.2, §12.5).</summary>
|
|
[Category("archive")]
|
|
public abstract class SequenceTrashTests(TestContext context) : DatabaseTest(context)
|
|
{
|
|
private async Task<ArchiveFixture> FixtureAsync() => Own(await CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
|
|
|
|
/// <summary>Three scanned sequences in <c>inbox/a</c>, <c>inbox/b</c> and <c>inbox/c</c>, by folder.</summary>
|
|
private static async Task<List<Sequence>> PopulateAsync(ArchiveFixture fx)
|
|
{
|
|
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "a"), Start, 3);
|
|
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "b"), Start.AddDays(1), 3, firstSeed: 10);
|
|
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "c"), Start.AddDays(2), 3, firstSeed: 20);
|
|
await fx.ScanAsync();
|
|
var sequences = new List<Sequence>();
|
|
foreach (var location in (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).OrderBy(l => l.Folder))
|
|
sequences.Add((await fx.Db.Sequences.GetAsync(location.Id))!);
|
|
return sequences;
|
|
}
|
|
|
|
private static (int Files, long Bytes) OnDisk(string folder)
|
|
{
|
|
var files = new DirectoryInfo(folder).EnumerateFiles("*", SearchOption.AllDirectories).ToList();
|
|
return (files.Count, files.Sum(f => f.Length));
|
|
}
|
|
|
|
/// <summary>One render of the sequence, stored in its exports folder.</summary>
|
|
private static async Task<Render> RenderAsync(ArchiveFixture fx, Sequence sequence)
|
|
{
|
|
var relative = sequence.Folder + "/exports/preview.mp4";
|
|
var path = fx.Paths.FromRelative(relative);
|
|
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
|
|
await File.WriteAllBytesAsync(path, new byte[1234]);
|
|
var render = new Render
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
SequenceId = sequence.Id,
|
|
PresetName = "720p preview",
|
|
OutputPath = relative,
|
|
Codec = "h264",
|
|
Width = 1280,
|
|
Height = 720,
|
|
Fps = 30,
|
|
DurationSeconds = 2,
|
|
Bytes = 1234,
|
|
Created = new DateTimeOffset(2026, 10, 1, 9, 0, 0, TimeSpan.Zero),
|
|
};
|
|
await fx.Db.Renders.InsertAsync(render);
|
|
return render;
|
|
}
|
|
|
|
private static Job Running(JobKind kind, IReadOnlyList<Guid> targets, string? parameters = null) => new()
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
Kind = kind,
|
|
TargetIds = targets,
|
|
ParametersJson = parameters,
|
|
State = JobState.Running,
|
|
NodeId = "test#0",
|
|
Created = DateTimeOffset.UtcNow,
|
|
Started = DateTimeOffset.UtcNow,
|
|
};
|
|
|
|
/// <summary>Makes the next write of <paramref name="operation"/> on the sequences table fail, as a lost database connection would.</summary>
|
|
private async Task FailSequencesAsync(ArchiveFixture fx, string operation)
|
|
{
|
|
await using var session = await fx.Db.Database.OpenAsync(fx.Ct);
|
|
await session.ExecuteScriptAsync(ForDialect(
|
|
$"CREATE TRIGGER fail_{operation} BEFORE {operation} ON sequences BEGIN SELECT RAISE(ABORT, 'injected'); END;",
|
|
$"CREATE FUNCTION fail_{operation}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'injected'; END $$; " +
|
|
$"CREATE TRIGGER fail_{operation} BEFORE {operation} ON sequences FOR EACH ROW EXECUTE FUNCTION fail_{operation}();"), fx.Ct);
|
|
}
|
|
|
|
private async Task HealSequencesAsync(ArchiveFixture fx, string operation)
|
|
{
|
|
await using var session = await fx.Db.Database.OpenAsync(fx.Ct);
|
|
await session.ExecuteScriptAsync(ForDialect($"DROP TRIGGER fail_{operation};", $"DROP TRIGGER fail_{operation} ON sequences;"), fx.Ct);
|
|
}
|
|
|
|
/// <summary>Reports on the calling thread, so a test can act between two sequences.</summary>
|
|
private sealed class Inline(Action<int> report) : IProgress<int>
|
|
{
|
|
public void Report(int value) => report(value);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheDryRunCountsWhatMovesAndChangesNothing()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id);
|
|
var folder = fx.Paths.Sequence(sequences[0].Folder).Folder;
|
|
|
|
var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], null, fx.Ct);
|
|
Assert.Empty(plan.Blocked);
|
|
Assert.Count(2, plan.Steps);
|
|
var (files, bytes) = OnDisk(folder);
|
|
Assert.Equal(files, plan.Steps[0].Files);
|
|
Assert.Equal(bytes, plan.Steps[0].Bytes);
|
|
Assert.Equal($".chronos/trash/{sequences[0].Id:N}", plan.Steps[0].TrashFolder);
|
|
Assert.Equal(6, plan.Frames);
|
|
Assert.Equal(before, await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id));
|
|
Assert.True(Directory.Exists(folder), "a dry run moves nothing");
|
|
Assert.False(Directory.Exists(SequenceTrash.TrashDirectory(fx.Paths)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task DeletingMovesTheWholeFolderToTheTrashAndDropsTheRows()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = sequences[1];
|
|
await RenderAsync(fx, victim);
|
|
var folder = fx.Paths.Sequence(victim.Folder).Folder;
|
|
var (files, bytes) = OnDisk(folder);
|
|
|
|
var plan = await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct);
|
|
var entries = await fx.Service.DeleteAsync(plan, "alberto", null, fx.Ct);
|
|
|
|
var entry = Assert.Contains(entries, e => e.SequenceId == victim.Id);
|
|
Assert.False(Directory.Exists(folder));
|
|
var trashed = Path.Combine(SequenceTrash.TrashDirectory(fx.Paths), entry.Name);
|
|
Assert.Equal((files, bytes), OnDisk(trashed));
|
|
Assert.Equal(victim.Id, ManifestStore.ReadSequence(fx.Paths.Sequence(fx.Paths.ToRelative(trashed)).ManifestPath).Id);
|
|
Assert.Null(await fx.Db.Sequences.GetAsync(victim.Id));
|
|
Assert.Empty(await fx.Db.Frames.ListBySequenceAsync(victim.Id));
|
|
Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(victim.Id));
|
|
Assert.NotNull(await fx.Db.Sequences.GetAsync(sequences[0].Id));
|
|
|
|
var listed = Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.SequenceId == victim.Id);
|
|
Assert.Equal("inbox/b", listed.Folder);
|
|
Assert.Equal(3, listed.Frames);
|
|
Assert.Equal("alberto", listed.DeletedBy);
|
|
|
|
// The trash is hidden from scans: nothing comes back on its own.
|
|
var scan = await fx.ScanAsync(ScanMode.Full);
|
|
Assert.Equal(2, scan.Folders);
|
|
Assert.Null(await fx.Db.Sequences.GetAsync(victim.Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task RestoringBringsBackTheSameIndexRowsAndRenders()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = sequences[0];
|
|
await fx.Db.Sequences.EditAsync(victim.Id, new Chronos.Data.Repositories.SequenceEdit { SettingsJson = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":41}}}""" }, null);
|
|
var render = await RenderAsync(fx, victim);
|
|
var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id);
|
|
var settings = (await fx.Db.Sequences.GetAsync(victim.Id))!.SettingsJson;
|
|
|
|
var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single();
|
|
var restored = await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct);
|
|
|
|
Assert.Equal(victim.Folder, restored.Folder);
|
|
Assert.Equal(settings, restored.SettingsJson);
|
|
Assert.Equal(1, restored.RenderedCount);
|
|
Assert.Equal(before, await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id));
|
|
Assert.Equal(render.OutputPath, (await fx.Db.Renders.ListBySequenceAsync(victim.Id)).Single().OutputPath);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
Assert.Empty(Directory.EnumerateFileSystemEntries(SequenceTrash.TrashDirectory(fx.Paths)));
|
|
Assert.Equal(0, (await fx.ScanAsync()).Indexed);
|
|
|
|
// Deleted again: the trash takes it again under the same name.
|
|
var again = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single();
|
|
Assert.Equal(entry.Name, again.Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceBackInTheIndexIsNotRestoredOverIt()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = sequences[1];
|
|
var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single();
|
|
await fx.Db.Sequences.UpsertAsync(victim);
|
|
|
|
var refused = await Assert.ThrowsAsync<SequenceInLibraryException>(() => fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct));
|
|
|
|
Assert.Equal(victim.Id, refused.SequenceId);
|
|
Assert.False(Directory.Exists(fx.Paths.Sequence(victim.Folder).Folder), "nothing moved");
|
|
Assert.Equal(entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ARestoreIntoATakenFolderUsesAFreeOneAndKeepsRendersReachable()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = sequences[2];
|
|
await RenderAsync(fx, victim);
|
|
var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single();
|
|
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "c"), Start.AddDays(5), 2, firstSeed: 40);
|
|
await fx.ScanAsync();
|
|
|
|
var restored = await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct);
|
|
Assert.Equal("inbox/c (2)", restored.Folder);
|
|
var output = (await fx.Db.Renders.ListBySequenceAsync(victim.Id)).Single().OutputPath;
|
|
Assert.Equal("inbox/c (2)/exports/preview.mp4", output);
|
|
Assert.FileExists(fx.Paths.FromRelative(output));
|
|
foreach (var frame in await fx.Db.Frames.ListBySequenceAsync(victim.Id)) Assert.FileExists(fx.Paths.FromRelative(frame.RelativePath));
|
|
Assert.Count(4, await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AFolderThatLostItsSidecarComesBackUnderItsId()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = await fx.Service.SetSequenceInfoAsync(sequences[1].Id, "Ridge", ["fog"], 4, "Tripod", fx.Ct);
|
|
var hero = (await fx.Db.Frames.ListBySequenceAsync(victim.Id)).Last().Id;
|
|
await fx.Db.Sequences.UpsertAsync(victim with { HeroFrameId = hero }, fx.Ct);
|
|
var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single();
|
|
var trashed = fx.Paths.Sequence(fx.Paths.ToRelative(Path.Combine(SequenceTrash.TrashDirectory(fx.Paths), entry.Name)));
|
|
File.Delete(trashed.ManifestPath);
|
|
|
|
var restored = await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct);
|
|
|
|
Assert.Equal(victim.Id, restored.Id);
|
|
Assert.Null(restored.HeroFrameId, "the frames were adopted with new ids");
|
|
var sidecar = ManifestStore.ReadSequence(fx.Paths.Sequence(victim.Folder).ManifestPath);
|
|
Assert.Equal(("Ridge", "fog", 4, "Tripod"), (sidecar.Title, sidecar.Tags.Single(), sidecar.Rating, sidecar.Notes));
|
|
Assert.Equal(("Ridge", 4), (restored.Title, restored.Rating));
|
|
Assert.Equal(victim.Folder, restored.Folder);
|
|
Assert.Equal(3, restored.FrameCount);
|
|
Assert.Count(3, await fx.Db.Frames.ListBySequenceAsync(victim.Id));
|
|
Assert.Equal(victim.Id, ManifestStore.ReadSequence(fx.Paths.Sequence(victim.Folder).ManifestPath).Id);
|
|
Assert.Equal(0, (await fx.ScanAsync()).Indexed, "the index and the new sidecar agree");
|
|
}
|
|
|
|
[Test]
|
|
public async Task SequencesThatCannotMoveAreBlockedAndUntouched()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "a", "night"), Start.AddDays(3), 2, firstSeed: 30);
|
|
await fx.ScanAsync();
|
|
await fx.Db.Jobs.EnqueueAsync(Running(JobKind.Proxies, [sequences[1].Id]));
|
|
// The folder of the third sequence now holds the sidecar of another sequence (copied over by hand).
|
|
File.Copy(fx.Paths.Sequence(sequences[0].Folder).ManifestPath, fx.Paths.Sequence(sequences[2].Folder).ManifestPath, overwrite: true);
|
|
|
|
var plan = await fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], null, fx.Ct);
|
|
Assert.Empty(plan.Steps);
|
|
Assert.SequenceEqual([DeleteBlock.ContainsSequences, DeleteBlock.Busy, DeleteBlock.ForeignSidecar],
|
|
plan.Blocked.OrderBy(b => b.Sequence.Folder, StringComparer.Ordinal).Select(b => b.Reason));
|
|
}
|
|
|
|
[Test]
|
|
public async Task APhotoFolderAdoptedAtTheRootNeverMoves()
|
|
{
|
|
var root = Context.CreateTempDirectory("adopted");
|
|
Photos.WriteSeries(root, Start, 2);
|
|
var fx = Own(await CreateAsync(Context, root, await NewOptionsAsync(multiConnection: true)));
|
|
await fx.ScanAsync();
|
|
var location = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single();
|
|
Assert.Equal(string.Empty, location.Folder);
|
|
|
|
var plan = await fx.Service.PlanDeleteAsync([location.Id], null, fx.Ct);
|
|
Assert.Equal(DeleteBlock.ArchiveRoot, plan.Blocked.Single().Reason);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AStalePlanIsRefusedBeforeAnythingMoves()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], null, fx.Ct);
|
|
await fx.Service.ApplyRenameAsync(await fx.Service.PlanRenameAsync(fx.Archive.Id, [sequences[1].Id], "moved/{date}", null, fx.Ct), null, fx.Ct);
|
|
|
|
var stale = await Assert.ThrowsAsync<StaleDeletePlanException>(() => fx.Service.DeleteAsync(plan, null, null, fx.Ct));
|
|
Assert.Equal(sequences[1].Id, stale.SequenceId);
|
|
Assert.True(Directory.Exists(fx.Paths.Sequence(sequences[0].Folder).Folder));
|
|
Assert.NotNull(await fx.Db.Sequences.GetAsync(sequences[0].Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ARowWhoseFolderIsMissingStaysForTheOrphansCheck()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
Directory.Delete(fx.Paths.Sequence(sequences[0].Folder).Folder, recursive: true);
|
|
|
|
var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id], null, fx.Ct);
|
|
Assert.Empty(plan.Steps);
|
|
Assert.Equal(DeleteBlock.FolderMissing, plan.Blocked.Single().Reason);
|
|
Assert.NotNull(await fx.Db.Sequences.GetAsync(sequences[0].Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceWithoutAFolderYetLosesOnlyItsRows()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var empty = new Sequence
|
|
{
|
|
Id = Guid.CreateVersion7(),
|
|
ArchiveId = fx.Archive.Id,
|
|
Title = "Waiting for photos",
|
|
Folder = string.Empty,
|
|
Origin = SequenceOrigin.Server,
|
|
SyncState = SyncState.InSync,
|
|
UpdatedAt = DateTimeOffset.UtcNow,
|
|
};
|
|
await fx.Db.Sequences.UpsertAsync(empty, fx.Ct);
|
|
|
|
var plan = await fx.Service.PlanDeleteAsync([empty.Id], null, fx.Ct);
|
|
Assert.Null(plan.Steps.Single().TrashFolder);
|
|
Assert.Empty(await fx.Service.DeleteAsync(plan, null, null, fx.Ct));
|
|
Assert.Null(await fx.Db.Sequences.GetAsync(empty.Id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task JobsOnTheWholeArchiveHoldEverySequenceOfIt()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var ids = sequences.Select(s => s.Id).ToList();
|
|
|
|
// A verify of one named sequence holds only that one.
|
|
var verifyOne = Running(JobKind.Verify, [fx.Archive.Id], ArchiveJobs.Verify(fx.Archive, [sequences[2].Id]).ParametersJson);
|
|
await fx.Db.Jobs.EnqueueAsync(verifyOne);
|
|
var plan = await fx.Service.PlanDeleteAsync(ids, null, fx.Ct);
|
|
Assert.Equal(sequences[2].Id, plan.Blocked.Single(b => b.Reason == DeleteBlock.Busy).Sequence.Id);
|
|
Assert.Count(2, plan.Steps);
|
|
|
|
// An import (whose folders only its plan knows) holds the whole archive, and so does a paused one.
|
|
var import = Running(JobKind.Import, [fx.Archive.Id]) with { State = JobState.Paused };
|
|
await fx.Db.Jobs.EnqueueAsync(import);
|
|
plan = await fx.Service.PlanDeleteAsync(ids, null, fx.Ct);
|
|
Assert.Empty(plan.Steps);
|
|
Assert.True(plan.Blocked.All(b => b.Reason == DeleteBlock.Busy));
|
|
|
|
// A plan made before the job started is refused when it runs.
|
|
await fx.Db.Jobs.SetStateAsync(import.Id, JobState.Done, null, fx.Ct);
|
|
var before = await fx.Service.PlanDeleteAsync([sequences[0].Id], null, fx.Ct);
|
|
await fx.Db.Jobs.EnqueueAsync(Running(JobKind.Scan, [fx.Archive.Id]));
|
|
await Assert.ThrowsAsync<StaleDeletePlanException>(() => fx.Service.DeleteAsync(before, null, null, fx.Ct));
|
|
Assert.True(Directory.Exists(fx.Paths.Sequence(sequences[0].Folder).Folder));
|
|
}
|
|
|
|
[Test]
|
|
public async Task WhenTheIndexCannotLetGoTheFolderComesBack()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = sequences[0];
|
|
var folder = fx.Paths.Sequence(victim.Folder).Folder;
|
|
var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id);
|
|
var plan = await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct);
|
|
|
|
await FailSequencesAsync(fx, "DELETE");
|
|
await Assert.ThrowsAsync<DatabaseException>(() => fx.Service.DeleteAsync(plan, null, null, fx.Ct));
|
|
|
|
Assert.True(Directory.Exists(folder), "the folder is back where it was");
|
|
Assert.Equal(before, await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id));
|
|
Assert.Empty(Directory.EnumerateFileSystemEntries(SequenceTrash.TrashDirectory(fx.Paths)));
|
|
await HealSequencesAsync(fx, "DELETE");
|
|
Assert.Count(1, await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ARestoreThatCannotBeIndexedLeavesTheEntryInTheTrash()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var victim = sequences[1];
|
|
var entry = (await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([victim.Id], null, fx.Ct), null, null, fx.Ct)).Single();
|
|
|
|
await FailSequencesAsync(fx, "INSERT");
|
|
await Assert.ThrowsAsync<DatabaseException>(() => fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct));
|
|
|
|
Assert.False(Directory.Exists(fx.Paths.Sequence(victim.Folder).Folder));
|
|
Assert.Null(await fx.Db.Sequences.GetAsync(victim.Id));
|
|
Assert.Equal(entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
await HealSequencesAsync(fx, "INSERT");
|
|
Assert.Equal(victim.Folder, (await fx.Service.RestoreAsync(fx.Archive.Id, entry.Name, fx.Ct)).Folder);
|
|
}
|
|
|
|
[Test]
|
|
public async Task CancellingStopsBetweenTwoWholeSequences()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var plan = await fx.Service.PlanDeleteAsync([sequences[0].Id, sequences[1].Id], null, fx.Ct);
|
|
using var cancel = CancellationTokenSource.CreateLinkedTokenSource(fx.Ct);
|
|
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => fx.Service.DeleteAsync(plan, null, new Inline(_ => cancel.Cancel()), cancel.Token));
|
|
|
|
Assert.Null(await fx.Db.Sequences.GetAsync(sequences[0].Id));
|
|
Assert.Count(1, await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
Assert.NotNull(await fx.Db.Sequences.GetAsync(sequences[1].Id));
|
|
Assert.True(Directory.Exists(fx.Paths.Sequence(sequences[1].Folder).Folder));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ACancelledDryRunStopsAndReportsWhatItChecked()
|
|
{
|
|
var fx = await FixtureAsync();
|
|
var sequences = await PopulateAsync(fx);
|
|
var checkedCounts = new List<int>();
|
|
var plan = await fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], new Inline(checkedCounts.Add), fx.Ct);
|
|
Assert.SequenceEqual([1, 2, 3], checkedCounts);
|
|
Assert.Count(3, plan.Steps);
|
|
|
|
using var cancel = CancellationTokenSource.CreateLinkedTokenSource(fx.Ct);
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() =>
|
|
fx.Service.PlanDeleteAsync([.. sequences.Select(s => s.Id)], new Inline(_ => cancel.Cancel()), cancel.Token));
|
|
}
|
|
}
|
|
|
|
public sealed class SqliteSequenceTrashTests(TestContext context) : SequenceTrashTests(context)
|
|
{
|
|
protected override Backend Backend => Backend.SqliteFile;
|
|
}
|
|
|
|
[RequiresEnvironment(PgTestServer.Variable)]
|
|
public sealed class PostgresSequenceTrashTests(TestContext context) : SequenceTrashTests(context)
|
|
{
|
|
protected override Backend Backend => Backend.Postgres;
|
|
}
|