diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx
index b48b5abb..0189e145 100644
--- a/i18n/en/Tooltips.resx
+++ b/i18n/en/Tooltips.resx
@@ -327,7 +327,7 @@
The settings that differ: your value, then the library's
Keep your values of these settings; they are sent to the library
Decide later and keep editing; Sync asks again
- Photos were added to or removed from this sequence in the library after the workspace copied it
+ The library added, removed, converted or verified photos of this sequence after the workspace copied it
Open project {0}, which holds your versionslong
Keep the library's values in this project, and send yours to a new project “{0}”{0} the new project's name
Versions saved here that wait to be sent to the library: {0}. Sync sends them{0} number of versions
diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx
index d3b216a5..46054e19 100644
--- a/i18n/it/Tooltips.it.resx
+++ b/i18n/it/Tooltips.it.resx
@@ -326,7 +326,7 @@
Le impostazioni diverse: il tuo valore, poi quello della libreria
Tieni i tuoi valori di queste impostazioni; vengono inviati alla libreria
Decidi più tardi e continua a modificare; Sincronizza lo chiede di nuovo
- Sono state aggiunte o tolte foto a questa sequenza nella libreria dopo che lo spazio di lavoro l'ha copiata
+ La libreria ha aggiunto, tolto, convertito o verificato foto di questa sequenza dopo che lo spazio di lavoro l'ha copiata
Apri il progetto {0}, che contiene le tue versioni
Tieni i valori della libreria in questo progetto e invia i tuoi a un nuovo progetto «{0}»
Versioni salvate qui in attesa di essere inviate alla libreria: {0}. Sincronizza le invia
diff --git a/src/Chronos.App/Editor/ProjectHistory.cs b/src/Chronos.App/Editor/ProjectHistory.cs
index fc396f9f..bb909cae 100644
--- a/src/Chronos.App/Editor/ProjectHistory.cs
+++ b/src/Chronos.App/Editor/ProjectHistory.cs
@@ -69,12 +69,23 @@ public sealed class ProjectHistory(ProjectSettings initial, int capacity = 200,
///
/// Adopts a project changed outside the editor (analysis advice, another client's edit merged on save) without an
/// undo step. Every undo and redo snapshot takes the same outside change, so undo reverts only the user's own steps
- /// and never brings back a value that predates the adopted change.
+ /// and never brings back a value that predates the adopted change. Settings of a newer Chronos on either side (a pull
+ /// took them: the project is shown read-only) are never merged with this one's (), so no step
+ /// can take that change: the undo and redo steps go instead, and undo never brings back values from before it.
///
public void Replace(ProjectSettings current)
{
ArgumentNullException.ThrowIfNull(current);
if (ProjectMerge.SameValues(current, Current)) return;
+ if (current.IsNewerFormat || Current.IsNewerFormat || _undo.Any(s => s.IsNewerFormat) || _redo.Any(s => s.IsNewerFormat))
+ {
+ _undo.Clear();
+ _redo.Clear();
+ _runKey = null;
+ Current = current;
+ Changed?.Invoke();
+ return;
+ }
var (basis, theirs) = (Current, current);
Func rebase = merge is null ? new ProjectMerge.Rebase(basis, theirs).Apply : step => merge(basis, step, theirs);
Rebase(_undo, rebase);
diff --git a/src/Chronos.App/Workspace/ProjectMenuViewModel.cs b/src/Chronos.App/Workspace/ProjectMenuViewModel.cs
index f6a49add..4c44b3d6 100644
--- a/src/Chronos.App/Workspace/ProjectMenuViewModel.cs
+++ b/src/Chronos.App/Workspace/ProjectMenuViewModel.cs
@@ -170,7 +170,8 @@ public sealed class ProjectMenuViewModel : LocalizedViewModel
var status = await _host.StatusAsync(ProjectId);
var moved = await _source.HomeFramesChangedAsync(CancellationToken.None);
if (_disposed) return;
- _homeFramesChanged = moved;
+ // Also photos the library named otherwise since the copy (hashed, converted) while the media could not learn it.
+ _homeFramesChanged = moved || status.MediaOutdated;
Apply(status);
}
catch (Exception ex) when (ex is not OutOfMemoryException)
diff --git a/src/Chronos.Core/Project/ProjectContent.cs b/src/Chronos.Core/Project/ProjectContent.cs
index 41fbfff5..3269106a 100644
--- a/src/Chronos.Core/Project/ProjectContent.cs
+++ b/src/Chronos.Core/Project/ProjectContent.cs
@@ -69,6 +69,21 @@ public static class ProjectContent
{
ArgumentNullException.ThrowIfNull(portableJson);
ArgumentNullException.ThrowIfNull(frames);
+ return Renamed(portableJson, frames, hashedOnly: true);
+ }
+
+ ///
+ /// The portable text with each pending frame whose photo hold named as the frame holding it is,
+ /// hashed or not, which copy of it included: what the text places on these frames, read so to compare two texts only
+ /// (). Unlike , a SHA-256 the frames do not know yet (the photo hashed where
+ /// the text was saved, not when the frames were copied) gives way to the frame's size and capture time, so a text saved
+ /// on hashed frames and one saved on frames not hashed yet read alike. Always canonical.
+ ///
+ private static string Bound(string portableJson, FramePhotos frames) => Canonical(Renamed(portableJson, frames, hashedOnly: false));
+
+ /// (: only onto frames that are hashed), else 's renaming.
+ private static string Renamed(string portableJson, FramePhotos frames, bool hashedOnly)
+ {
if (frames.Count == 0 || !portableJson.Contains("pendingFrames", StringComparison.OrdinalIgnoreCase)) return portableJson;
if (FormatOf(portableJson) > ProjectSettings.CurrentVersion) return portableJson;
if (JsonNode.Parse(portableJson, new JsonNodeOptions { PropertyNameCaseInsensitive = true }) is not JsonObject project
@@ -81,15 +96,17 @@ public static class ProjectContent
DateTime? captured = entry["capturedAt"] is JsonValue t && t.TryGetValue(out var time) ? time : null;
if (string.IsNullOrEmpty(sha) && (captured is null || size < 0)) continue;
var occurrence = entry["occurrence"] is JsonValue o && o.TryGetValue(out var n) && n > 0 ? n : 0;
- // Only a frame that is hashed names a photo better than the entry does.
- if (frames.IndexOf(new FramePhoto(sha, size, captured), occurrence) is not { } at || frames[at] is not { IsHashed: true } held) continue;
+ // Only a frame that is hashed names a photo better than the entry does (to keep; to compare, any frame does).
+ if (frames.IndexOf(new FramePhoto(sha, size, captured), occurrence) is not { } at || frames[at] is not { } held || (hashedOnly && !held.IsHashed)) continue;
// The copy a placement looks for under the new name: among the frames holding that SHA-256, not those of that size and time.
var copy = frames.Occurrence(at);
var sameTime = held.CapturedAt is { } heldAt
? captured is { } entryAt && FramePhoto.Millisecond(heldAt) == FramePhoto.Millisecond(entryAt)
: captured is null;
- if (string.Equals(held.Sha256, sha, StringComparison.OrdinalIgnoreCase) && held.Size == size && sameTime && copy == occurrence) continue;
- entry["sha256"] = held.Sha256!.ToLowerInvariant();
+ if (string.Equals(held.Sha256 ?? string.Empty, sha ?? string.Empty, StringComparison.OrdinalIgnoreCase) && held.Size == size && sameTime
+ && copy == occurrence) continue;
+ if (held.IsHashed) entry["sha256"] = held.Sha256!.ToLowerInvariant();
+ else entry.Remove("sha256");
entry["size"] = held.Size;
if (held.CapturedAt is { } heldTime) entry["capturedAt"] = heldTime;
else entry.Remove("capturedAt");
@@ -169,7 +186,9 @@ public static class ProjectContent
///
/// Whether two portable texts hold the same choices on the frames of : the same text, or the
- /// same once their pending frames are named as the frames hold their photos now ().
+ /// same once their pending frames are named as the frames hold their photos now (), or as the frame
+ /// each lands on is named, hashed or not (): a version saved where a photo was hashed after these
+ /// frames were copied holds what a working state saved on them does, so it reads neither as a change nor as one to save.
///
/// A text is not a project object.
public static bool SameChoices(string portable, string other, FramePhotos frames)
@@ -177,7 +196,9 @@ public static class ProjectContent
ArgumentNullException.ThrowIfNull(portable);
ArgumentNullException.ThrowIfNull(other);
ArgumentNullException.ThrowIfNull(frames);
- return portable == other || (frames.Count > 0 && Rebind(portable, frames) == Rebind(other, frames));
+ if (portable == other) return true;
+ if (frames.Count == 0) return false;
+ return Rebind(portable, frames) == Rebind(other, frames) || (frames.HasUnhashed && Bound(portable, frames) == Bound(other, frames));
}
///
diff --git a/src/Chronos.Data/Workspaces/WorkspaceSync.cs b/src/Chronos.Data/Workspaces/WorkspaceSync.cs
index 8a76265d..1bcbf590 100644
--- a/src/Chronos.Data/Workspaces/WorkspaceSync.cs
+++ b/src/Chronos.Data/Workspaces/WorkspaceSync.cs
@@ -1,5 +1,6 @@
using System.Globalization;
using System.Text.Json;
+using Chronos.Core.Archiving;
using Chronos.Core.Diagnostics;
using Chronos.Core.Model;
using Chronos.Core.Project;
@@ -46,7 +47,16 @@ public enum WorkspaceState
/// The home's version the project was last in step with.
/// The home's newest version, when it was asked.
public sealed record WorkspaceStatus(WorkspaceState State, bool Modified, int Ahead, int Behind, bool Offline, bool MediaRemoved, bool ReadOnly,
- WorkspaceConflict? Conflict, BundleBase? Base, ProjectVersion? HomeHead);
+ WorkspaceConflict? Conflict, BundleBase? Base, ProjectVersion? HomeHead)
+{
+ ///
+ /// The media are behind the home's frames, as the home was asked: frames added, removed or converted there since the copy
+ /// (Update media copies them again), or photos the home names otherwise now (hashed, or joined to another encoding,
+ /// there since) whose names the media could not learn yet because another operation held the project. Every sync
+ /// teaches the media the home's names; false without a home asked.
+ ///
+ public bool MediaOutdated { get; init; }
+}
/// What a push, pull or resolve did: the versions it stored at the home and those it took from there, and where it left the project.
/// After : the new project at the home holding this workspace's versions.
@@ -134,7 +144,7 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
/// The project of brought into the workspace: its folder, the home's
/// head as the base and the working state (positions waiting for the media, which a
/// job copies: ). A project already here is left as
- /// it is.
+ /// it is, but for its media's names of the photos ().
///
/// The home has no such project.
/// A project of that id from another home is in the workspace.
@@ -150,6 +160,15 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
var existing = project.ReadBundle();
if (existing.Workspace!.Home.SequenceId != sequence.Home.SequenceId)
throw new InvalidOperationException($"Project {projectId} in the workspace belongs to another sequence.");
+ // Opened again: its media learn how the home names its photos now, as a sync's do (damaged ones are copied again).
+ try
+ {
+ await MediaNamedAsAtHomeAsync(project, home, cancellationToken).ConfigureAwait(false);
+ }
+ catch (InvalidDataException ex)
+ {
+ Log.Warning("workspace", $"The media index of workspace project {projectId} cannot be read", ex);
+ }
return project;
}
var listed = (await home.ListAsync(cancellationToken).ConfigureAwait(false)).FirstOrDefault(p => p.Id == projectId)
@@ -378,11 +397,14 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
}
- /// Where the project stands; with a , against the home's head too (offline when it cannot be reached).
+ ///
+ /// Where the project stands; with a , against the home's head too (offline when it cannot be
+ /// reached), the media naming the photos as the home does now (written when the project's lease is free).
+ ///
public async Task StatusAsync(Guid projectId, IProjectHome? home = null, CancellationToken cancellationToken = default)
{
var project = Existing(projectId);
- return await StatusLockedAsync(project, home, cancellationToken).ConfigureAwait(false);
+ return await StatusLockedAsync(project, home, cancellationToken, leased: false).ConfigureAwait(false);
}
/// The versions this workspace saved and has not pushed yet, oldest first.
@@ -767,7 +789,14 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
return version;
}
- private async Task StatusLockedAsync(WorkspaceProject project, IProjectHome? home, CancellationToken cancellationToken)
+ ///
+ /// Where the project stands. With a , the media first learn how it names its photos now (a photo
+ /// hashed or converted there since the copy, ), so a version the home made since
+ /// and the working state name each photo alike: written at once while the project's lease is held
+ /// (), else when it can be taken without waiting (
+ /// when it cannot).
+ ///
+ private async Task StatusLockedAsync(WorkspaceProject project, IProjectHome? home, CancellationToken cancellationToken, bool leased = true)
{
var bundle = project.ReadBundle();
var workspace = bundle.Workspace!;
@@ -782,22 +811,32 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
}
var conflict = project.ReadSync().Conflict;
var locals = Unpushed(project, bundle);
- var tipHash = locals.Count > 0 ? locals[^1].ContentHash : workspace.Base?.ContentHash;
- var modified = !bundle.IsReadOnly && (Portable(bundle.Project, media) is not { } portable
- || (ProjectContent.Hash(portable) != tipHash && !SameAsTip(project, bundle, locals, portable, media)));
ProjectVersion? head = null;
+ HomeFrames? frames = null;
var offline = false;
if (home is not null)
{
try
{
head = await home.HeadAsync(project.ProjectId, cancellationToken).ConfigureAwait(false);
+ if (media is not null) frames = await home.FramesAsync(cancellationToken).ConfigureAwait(false);
}
catch (HomeUnavailableException)
{
offline = true;
}
}
+ var outdated = false;
+ if (media is not null && frames is not null)
+ {
+ var named = media.NamedAsAt(frames);
+ if (!ReferenceEquals(named, media)) outdated = !await LearnNamesAsync(project, frames, leased, cancellationToken).ConfigureAwait(false);
+ outdated |= frames.FramesVersion != media.FramesVersion;
+ media = named;
+ }
+ var tipHash = locals.Count > 0 ? locals[^1].ContentHash : workspace.Base?.ContentHash;
+ var modified = !bundle.IsReadOnly && (Portable(bundle.Project, media) is not { } portable
+ || (ProjectContent.Hash(portable) != tipHash && !SameAsTip(project, bundle, locals, portable, media)));
var behind = head is not null && head.Id != workspace.Base?.VersionId ? Math.Max(1, head.Number - (workspace.Base?.Number ?? 0)) : 0;
// A local commit the home stored although its answer was lost reads as behind by the commits it holds: they are ours.
if (head is not null && locals.Any(v => v.Id == head.Id)) behind = 0;
@@ -808,7 +847,36 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
: locals.Count > 0 ? WorkspaceState.Ahead
: modified ? WorkspaceState.Modified
: WorkspaceState.InSync;
- return new WorkspaceStatus(state, modified, locals.Count, behind, offline, media is null, bundle.IsReadOnly, conflict, workspace.Base, head);
+ return new WorkspaceStatus(state, modified, locals.Count, behind, offline, media is null, bundle.IsReadOnly, conflict, workspace.Base, head)
+ {
+ MediaOutdated = outdated,
+ };
+ }
+
+ ///
+ /// Writes the media with the photos named as name them (read again under the lease: a copy
+ /// may have written new media meanwhile); without , only when the lease is free now. Whether
+ /// the media know the home's names.
+ ///
+ private async Task LearnNamesAsync(WorkspaceProject project, HomeFrames frames, bool leased, CancellationToken cancellationToken)
+ {
+ IDisposable? lease = null;
+ try
+ {
+ if (!leased) lease = await project.LockAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+ if (project.ReadMedia() is not { } media) return false;
+ var named = media.NamedAsAt(frames);
+ if (!ReferenceEquals(named, media)) project.WriteMedia(named);
+ return true;
+ }
+ catch (Exception ex) when (ex is LeaseUnavailableException or InvalidDataException)
+ {
+ return false;
+ }
+ finally
+ {
+ lease?.Dispose();
+ }
}
///
diff --git a/tests/Chronos.App.Tests/Editor/ProjectHistoryTests.cs b/tests/Chronos.App.Tests/Editor/ProjectHistoryTests.cs
index 33ad5a47..f7e8505a 100644
--- a/tests/Chronos.App.Tests/Editor/ProjectHistoryTests.cs
+++ b/tests/Chronos.App.Tests/Editor/ProjectHistoryTests.cs
@@ -1,5 +1,6 @@
using Chronos.App.Editor;
using Chronos.Core.Project;
+using Chronos.Data.Projects;
using Chronos.Testing;
namespace Chronos.App.Tests.Editor;
@@ -113,6 +114,38 @@ public sealed class ProjectHistoryTests
Assert.Null(history.Current.HeroFrame, "the user's step reverts the value it set");
}
+ [Test]
+ public void SettingsOfANewerChronosAdoptedDropTheStepsInsteadOfMergingThem()
+ {
+ var newer = ProjectSettings.FromJson("""{ "version": 2, "exposure": { "exposureOffsetEv": 1.5 }, "grade": { "look": "film" } }""", allowNewer: true);
+ // The workspace's merge throws as ProjectMerge does where both sides changed and one is a newer Chronos's.
+ foreach (var merge in new Func?[]
+ { null, (basis, ours, theirs) => ProjectMerge.MergeWithConflicts(basis, ours, theirs).Merged })
+ {
+ var history = new ProjectHistory(new ProjectSettings(), merge: merge);
+ history.Apply(WithOffset(history.Current, 0.3));
+ history.Apply(history.Current with { HeroFrame = 2 });
+ history.Undo();
+ Assert.True(history.CanUndo && history.CanRedo);
+ var changes = 0;
+ history.Changed += () => changes++;
+
+ // A pull took the newer settings (nothing of the editor's waited): shown as they are, read-only.
+ history.Replace(newer);
+ Assert.True(history.Current.IsNewerFormat);
+ Assert.Equal(1.5, history.Current.Exposure.ExposureOffsetEv);
+ Assert.False(history.CanUndo, "no step brings back this Chronos's values over a newer one's");
+ Assert.False(history.CanRedo);
+ Assert.False(history.Undo());
+ Assert.Equal(1, changes);
+
+ // Back to this Chronos's format (a Save both took another project): nothing is merged into the newer settings either.
+ history.Replace(WithOffset(new ProjectSettings(), 0.6));
+ Assert.Equal(0.6, history.Current.Exposure.ExposureOffsetEv);
+ Assert.False(history.CanUndo);
+ }
+ }
+
[Test]
public void EndingARunMakesTheNextEditANewStep()
{
diff --git a/tests/Chronos.App.Tests/Workspace/WorkspaceNewerFormatTests.cs b/tests/Chronos.App.Tests/Workspace/WorkspaceNewerFormatTests.cs
new file mode 100644
index 00000000..21775e98
--- /dev/null
+++ b/tests/Chronos.App.Tests/Workspace/WorkspaceNewerFormatTests.cs
@@ -0,0 +1,49 @@
+using Chronos.Core.Project;
+using Chronos.Testing;
+
+namespace Chronos.App.Tests.Workspace;
+
+///
+/// The editor of a workspace project whose home moved to settings of a newer Chronos (owner review 2, R8): shown read-only,
+/// never merged with this Chronos's, the editor usable whatever its undo steps hold.
+///
+[Category("workspace")]
+public sealed class WorkspaceNewerFormatTests(TestContext context)
+{
+ private static ProjectSettings Exposure(ProjectSettings p, double ev) => p with { Exposure = p.Exposure with { ExposureOffsetEv = ev } };
+
+ [Test]
+ public async Task AnEditorWithUndoStepsTakesANewerChronossSettingsReadOnly()
+ {
+ await using var bed = await WorkspaceTestBed.CreateAsync(context);
+ var host = bed.Host();
+ var projectId = await bed.CheckoutAsync(host);
+ var (_, session) = await bed.OpenAsync(host, projectId);
+ await using (session)
+ {
+ // Edited, saved and kept as a version: every edit is stored, the undo steps stay.
+ Assert.True(session.Edit(p => Exposure(p, 0.4)));
+ Assert.True(session.Edit(p => p with { ExcludedFrames = [2] }));
+ Assert.True(await session.FlushAsync());
+ Assert.NotNull(await host.CommitAsync(projectId, bed.Ct));
+ Assert.True(session.History.CanUndo);
+
+ // A pull with nothing of this PC's waiting moved the working state onto a newer Chronos's settings.
+ var folder = host.Store.Find(projectId)!;
+ var stored = folder.ReadBundle();
+ folder.WriteBundle(stored with { Project = Exposure(stored.Project, 1.5) with { Version = ProjectSettings.CurrentVersion + 1 } });
+ await session.ReloadAsync();
+
+ Assert.True(session.IsReadOnly);
+ Assert.True(session.Project.IsNewerFormat);
+ Assert.Equal(1.5, session.Project.Exposure.ExposureOffsetEv);
+ Assert.False(session.History.CanUndo, "no step brings this Chronos's values back over the newer ones");
+ Assert.False(session.Undo());
+ Assert.False(session.Edit(p => Exposure(p, 0.2)));
+ Assert.False(session.HasPendingSave);
+ // Read again (another analysis, another pull): the editor stays as it is.
+ await session.ReloadAsync();
+ Assert.Equal(1.5, session.Project.Exposure.ExposureOffsetEv);
+ }
+ }
+}
diff --git a/tests/Chronos.Core.Tests/Project/ProjectContentTests.cs b/tests/Chronos.Core.Tests/Project/ProjectContentTests.cs
index 44e9db62..ef1de52d 100644
--- a/tests/Chronos.Core.Tests/Project/ProjectContentTests.cs
+++ b/tests/Chronos.Core.Tests/Project/ProjectContentTests.cs
@@ -135,6 +135,29 @@ public sealed class ProjectContentTests
Assert.Equal(newer, ProjectContent.Rebind(newer, now));
}
+ [Test]
+ public void ChoicesSavedWhereAPhotoWasHashedReadAsTheSameOnFramesCopiedBeforeIt()
+ {
+ // A workspace copied photo 1 before its home hashed it; a version the home made since names it by its SHA-256.
+ var copied = Frames(Photo(1, hashed: false), Photo(2), Photo(3));
+ var home = Frames(Photo(1), Photo(2), Photo(3));
+ var choices = new ProjectSettings { ExcludedFrames = [0], Camera = new CameraSettings { Keyframes = [new CameraKey(0, 0.3, 0.5, 1.2, 0)] } };
+ var atHome = ProjectContent.ToPortable(choices, home);
+ var here = ProjectContent.ToPortable(choices, copied);
+ Assert.NotEqual(atHome, here);
+
+ // The same choices on the frames held here: no change to show or to save as a version.
+ Assert.True(ProjectContent.SameChoices(atHome, here, copied));
+ Assert.True(ProjectContent.SameChoices(here, atHome, copied));
+ // What is kept keeps the hash the frames do not know yet; a choice of its own still differs.
+ Assert.Equal(atHome, ProjectContent.Rebind(atHome, copied));
+ Assert.False(ProjectContent.SameChoices(atHome, ProjectContent.ToPortable(new ProjectSettings { ExcludedFrames = [1] }, copied), copied));
+ Assert.False(ProjectContent.SameChoices(atHome, ProjectContent.ToPortable(choices with { ExcludedFrames = [] }, copied), copied));
+ // A photo none of the frames holds is compared as it is named.
+ var gone = ProjectContent.ToPortable(choices, Frames(Photo(4)));
+ Assert.False(ProjectContent.SameChoices(gone, ProjectContent.ToPortable(choices, Frames(Photo(4, hashed: false))), copied));
+ }
+
[Test]
public void APhotoOfABurstToldApartByItsOrderKeepsItsPositionOnceHashed()
{
diff --git a/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs b/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs
index d36d43ce..ed8518d3 100644
--- a/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs
+++ b/tests/Chronos.Data.Tests/Workspaces/WorkspaceMergeTests.cs
@@ -118,6 +118,102 @@ public abstract class WorkspaceMergeTests(TestContext context) : DatabaseTest(co
Assert.Null(await sync.CommitAsync(id, cancellationToken: fx.Ct));
}
+ [Test]
+ public async Task ABaseNamingAPhotoByItsHashReadsAsTheWorkingStateOnMediaThatHaveNotLearntIt()
+ {
+ var fx = await FixtureAsync();
+ await UnhashAsync(fx, 2);
+ var (_, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ var copied = project.ReadMedia()!;
+ await EditAsync(sync, id, s => s with { ExcludedFrames = [2] }, fx.Ct);
+ await sync.CommitAsync(id, cancellationToken: fx.Ct);
+ await sync.PushAsync(id, fx.Home, fx.Ct);
+ await VerifyAsync(fx);
+ await WriteAtHomeAsync(fx, s => s with { Exposure = s.Exposure with { ExposureOffsetEv = 0.7 } });
+ Assert.Equal(WorkspaceState.InSync, (await sync.PullAsync(id, fx.Home, fx.Ct)).Status.State);
+ var hashed = (await fx.Db.Frames.ListBySequenceAsync(fx.Sequence.Id))[2].Sha256!;
+ Assert.Contains(hashed, (await fx.Home.HeadAsync(id, fx.Ct)).SettingsJson);
+
+ // Media that have not learnt the hash (copied so, the home out of reach since): the base still holds the working state.
+ project.WriteMedia(copied);
+ var status = await sync.StatusAsync(id, cancellationToken: fx.Ct);
+ Assert.Equal((WorkspaceState.InSync, false), (status.State, status.Modified));
+ Assert.Null(await sync.CommitAsync(id, cancellationToken: fx.Ct));
+ Assert.Empty(sync.Unpushed(id));
+
+ // A change of the user's own still reads as one, and its version keeps the exclusion.
+ await EditAsync(sync, id, s => s with { Exposure = s.Exposure with { ExposureOffsetEv = 0.9 } }, fx.Ct);
+ Assert.True((await sync.StatusAsync(id, cancellationToken: fx.Ct)).Modified);
+ var saved = Assert.NotNull(await sync.CommitAsync(id, cancellationToken: fx.Ct));
+ Assert.SequenceEqual([2], ProjectSettings.FromJson(ProjectContent.Place(saved.SettingsJson, copied.Photos)).ExcludedFrames);
+ Assert.Equal(WorkspaceState.InSync, (await sync.PushAsync(id, fx.Home, fx.Ct)).Status.State);
+ var settings = await SequenceSettingsAsync(fx);
+ Assert.Equal((0.9, 2), (settings.Exposure.ExposureOffsetEv, settings.ExcludedFrames.Single()));
+ }
+
+ [Test]
+ public async Task APhotoHashedAtTheHomeIsOutdatedMediaUntilTheMediaLearnItsHash()
+ {
+ var fx = await FixtureAsync();
+ await UnhashAsync(fx, 2);
+ var (_, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ await EditAsync(sync, id, s => s with { ExcludedFrames = [2] }, fx.Ct);
+ await sync.CommitAsync(id, cancellationToken: fx.Ct);
+ await sync.PushAsync(id, fx.Home, fx.Ct);
+ Assert.False((await sync.StatusAsync(id, fx.Home, fx.Ct)).MediaOutdated);
+ await VerifyAsync(fx);
+ await WriteAtHomeAsync(fx, s => s with { Exposure = s.Exposure with { ExposureOffsetEv = 0.7 } });
+ var hashed = (await fx.Db.Frames.ListBySequenceAsync(fx.Sequence.Id))[2].Sha256!;
+
+ // Asked while another operation holds the project: outdated, the media as they were, nothing to save here.
+ WorkspaceStatus busy;
+ using (await project.LockAsync(TimeSpan.FromSeconds(TestTiming.Budget(10)), fx.Ct))
+ busy = await sync.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.True(busy.MediaOutdated);
+ Assert.Equal((WorkspaceState.Behind, false), (busy.State, busy.Modified));
+ Assert.Null(project.ReadMedia()!.Frames[2].Sha256);
+ Assert.False((await sync.StatusAsync(id, cancellationToken: fx.Ct)).MediaOutdated, "without a home nothing is known of it");
+
+ // Asked again with the project free: the media learn the hash, the frames and their files as copied.
+ var learnt = await sync.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.False(learnt.MediaOutdated);
+ Assert.Equal((WorkspaceState.Behind, false), (learnt.State, learnt.Modified));
+ Assert.Equal(hashed, project.ReadMedia()!.Frames[2].Sha256);
+ var pulled = await sync.PullAsync(id, fx.Home, fx.Ct);
+ Assert.Equal((WorkspaceState.InSync, false), (pulled.Status.State, pulled.Status.MediaOutdated));
+ Assert.SequenceEqual([2], (await sync.OpenAsync(id, fx.Ct)).Working.ExcludedFrames);
+ }
+
+ [Test]
+ public async Task APhotoConvertedAtTheHomeIsOutdatedMediaAndTheMediaLearnItsEncodings()
+ {
+ var fx = await FixtureAsync(4);
+ var (store, sync) = fx.Workspace();
+ var project = await fx.CheckoutAsync(sync);
+ var id = project.ProjectId;
+ var copied = project.ReadMedia()!;
+ Assert.Null(copied.Aliases);
+ await ProjectServiceTests.ConvertAsync(fx.Archive, fx.Sequence.Id, [1], 700);
+ var converted = (await fx.Db.Frames.ListBySequenceAsync(fx.Sequence.Id))[1].Sha256!;
+
+ // Opened again: the media learn the encodings the conversion joined, but still hold the photo as copied.
+ await sync.CheckoutAsync(fx.Home, id, cancellationToken: fx.Ct);
+ var link = Assert.NotNull(project.ReadMedia()!.Aliases).Single();
+ Assert.Equal((copied.Frames[1].Sha256!.ToLowerInvariant(), converted.ToLowerInvariant()), (link.Sha256.ToLowerInvariant(), link.Replacement.ToLowerInvariant()));
+ Assert.Equal(copied.Frames[1].Sha256, project.ReadMedia()!.Frames[1].Sha256);
+ var status = await sync.StatusAsync(id, fx.Home, fx.Ct);
+ Assert.True(status.MediaOutdated, "the file is not the library's any more: Update media copies it again");
+ Assert.False(status.Modified);
+
+ await fx.CopyAsync(store, id);
+ Assert.False((await sync.StatusAsync(id, fx.Home, fx.Ct)).MediaOutdated);
+ Assert.Equal(converted, project.ReadMedia()!.Frames[1].Sha256);
+ }
+
[Test]
public async Task AVersionSavedBeforeAnotherWorkspaceNamedThePhotoByItsHashKeepsItsEdit()
{