Merge branch 'review2-p5a-fix2-merge' into review2-p5a-int2
This commit is contained in:
commit
fd35e83dfc
10 files changed
+321
-19
No files matched your search
@@ -327,7 +327,7 @@
|
||||
<data name="Tooltips.Editor.Workspace.Differences" xml:space="preserve"><value>The settings that differ: your value, then the library's</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.KeepMine" xml:space="preserve"><value>Keep your values of these settings; they are sent to the library</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.Later" xml:space="preserve"><value>Decide later and keep editing; Sync asks again</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.MediaChanged" xml:space="preserve"><value>Photos were added to or removed from this sequence in the library after the workspace copied it</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.MediaChanged" xml:space="preserve"><value>The library added, removed, converted or verified photos of this sequence after the workspace copied it</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.OpenCopy" xml:space="preserve"><value>Open project {0}, which holds your versions</value><comment>long</comment></data>
|
||||
<data name="Tooltips.Editor.Workspace.SaveBoth" xml:space="preserve"><value>Keep the library's values in this project, and send yours to a new project “{0}”</value><comment>{0} the new project's name</comment></data>
|
||||
<data name="Tooltips.Editor.Workspace.State.Ahead" xml:space="preserve"><value>Versions saved here that wait to be sent to the library: {0}. Sync sends them</value><comment>{0} number of versions</comment></data>
|
||||
|
||||
@@ -326,7 +326,7 @@
|
||||
<data name="Tooltips.Editor.Workspace.Differences" xml:space="preserve"><value>Le impostazioni diverse: il tuo valore, poi quello della libreria</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.KeepMine" xml:space="preserve"><value>Tieni i tuoi valori di queste impostazioni; vengono inviati alla libreria</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.Later" xml:space="preserve"><value>Decidi più tardi e continua a modificare; Sincronizza lo chiede di nuovo</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.MediaChanged" xml:space="preserve"><value>Sono state aggiunte o tolte foto a questa sequenza nella libreria dopo che lo spazio di lavoro l'ha copiata</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.MediaChanged" xml:space="preserve"><value>La libreria ha aggiunto, tolto, convertito o verificato foto di questa sequenza dopo che lo spazio di lavoro l'ha copiata</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.OpenCopy" xml:space="preserve"><value>Apri il progetto {0}, che contiene le tue versioni</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.SaveBoth" xml:space="preserve"><value>Tieni i valori della libreria in questo progetto e invia i tuoi a un nuovo progetto «{0}»</value></data>
|
||||
<data name="Tooltips.Editor.Workspace.State.Ahead" xml:space="preserve"><value>Versioni salvate qui in attesa di essere inviate alla libreria: {0}. Sincronizza le invia</value></data>
|
||||
|
||||
@@ -69,12 +69,23 @@ public sealed class ProjectHistory(ProjectSettings initial, int capacity = 200,
|
||||
/// <summary>
|
||||
/// 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 (<see cref="ProjectMerge"/>), so no step
|
||||
/// can take that change: the undo and redo steps go instead, and undo never brings back values from before it.
|
||||
/// </summary>
|
||||
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<ProjectSettings, ProjectSettings> rebase = merge is null ? new ProjectMerge.Rebase(basis, theirs).Apply : step => merge(basis, step, theirs);
|
||||
Rebase(_undo, rebase);
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -69,6 +69,21 @@ public static class ProjectContent
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(portableJson);
|
||||
ArgumentNullException.ThrowIfNull(frames);
|
||||
return Renamed(portableJson, frames, hashedOnly: true);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The portable text with each pending frame whose photo <paramref name="frames"/> 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
|
||||
/// (<see cref="SameChoices"/>). Unlike <see cref="Rebind"/>, 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.
|
||||
/// </summary>
|
||||
private static string Bound(string portableJson, FramePhotos frames) => Canonical(Renamed(portableJson, frames, hashedOnly: false));
|
||||
|
||||
/// <summary><see cref="Rebind"/> (<paramref name="hashedOnly"/>: only onto frames that are hashed), else <see cref="Bound"/>'s renaming.</summary>
|
||||
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<DateTime>(out var time) ? time : null;
|
||||
if (string.IsNullOrEmpty(sha) && (captured is null || size < 0)) continue;
|
||||
var occurrence = entry["occurrence"] is JsonValue o && o.TryGetValue<int>(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
|
||||
|
||||
/// <summary>
|
||||
/// Whether two portable texts hold the same choices on the frames of <paramref name="frames"/>: the same text, or the
|
||||
/// same once their pending frames are named as the frames hold their photos now (<see cref="Rebind"/>).
|
||||
/// same once their pending frames are named as the frames hold their photos now (<see cref="Rebind"/>), or as the frame
|
||||
/// each lands on is named, hashed or not (<see cref="Bound"/>): 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.
|
||||
/// </summary>
|
||||
/// <exception cref="JsonException">A text is not a project object.</exception>
|
||||
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));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -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
|
||||
/// <param name="Base">The home's version the project was last in step with.</param>
|
||||
/// <param name="HomeHead">The home's newest version, when it was asked.</param>
|
||||
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)
|
||||
{
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
public bool MediaOutdated { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>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.</summary>
|
||||
/// <param name="SavedAs">After <see cref="ConflictChoice.SaveBoth"/>: the new project at the home holding this workspace's versions.</param>
|
||||
@@ -134,7 +144,7 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
|
||||
/// The project <paramref name="projectId"/> of <paramref name="home"/> brought into the workspace: its folder, the home's
|
||||
/// head as the base and the working state (positions waiting for the media, which a
|
||||
/// <see cref="JobKind.WorkspaceCopy"/> job copies: <see cref="WorkspaceJobs.Copy"/>). A project already here is left as
|
||||
/// it is.
|
||||
/// it is, but for its media's names of the photos (<see cref="WorkspaceMedia.NamedAsAt"/>).
|
||||
/// </summary>
|
||||
/// <exception cref="ProjectException">The home has no such project.</exception>
|
||||
/// <exception cref="InvalidOperationException">A project of that id from another home is in the workspace.</exception>
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Where the project stands; with a <paramref name="home"/>, against the home's head too (offline when it cannot be reached).</summary>
|
||||
/// <summary>
|
||||
/// Where the project stands; with a <paramref name="home"/>, 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).
|
||||
/// </summary>
|
||||
public async Task<WorkspaceStatus> 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);
|
||||
}
|
||||
|
||||
/// <summary>The versions this workspace saved and has not pushed yet, oldest first.</summary>
|
||||
@@ -767,7 +789,14 @@ public sealed class WorkspaceSync(WorkspaceStore store, string clientName)
|
||||
return version;
|
||||
}
|
||||
|
||||
private async Task<WorkspaceStatus> StatusLockedAsync(WorkspaceProject project, IProjectHome? home, CancellationToken cancellationToken)
|
||||
/// <summary>
|
||||
/// Where the project stands. With a <paramref name="home"/>, the media first learn how it names its photos now (a photo
|
||||
/// hashed or converted there since the copy, <see cref="WorkspaceMedia.NamedAsAt"/>), 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
|
||||
/// (<paramref name="leased"/>), else when it can be taken without waiting (<see cref="WorkspaceStatus.MediaOutdated"/>
|
||||
/// when it cannot).
|
||||
/// </summary>
|
||||
private async Task<WorkspaceStatus> 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,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes the media with the photos named as <paramref name="frames"/> name them (read again under the lease: a copy
|
||||
/// may have written new media meanwhile); without <paramref name="leased"/>, only when the lease is free now. Whether
|
||||
/// the media know the home's names.
|
||||
/// </summary>
|
||||
private async Task<bool> 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();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -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<ProjectSettings, ProjectSettings, ProjectSettings, ProjectSettings>?[]
|
||||
{ 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()
|
||||
{
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
using Chronos.Core.Project;
|
||||
using Chronos.Testing;
|
||||
|
||||
namespace Chronos.App.Tests.Workspace;
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
[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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
{
|
||||
|
||||
@@ -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()
|
||||
{
|
||||
|
||||
Reference in new issue
Block a user