The owner asked (2026-11-06) that whatever path is given as the archive root, on the server in Docker or on Windows, Chronos creates inside it every folder the archive keeps. Until now only .chronos was made up front; locks, journal, staging, trash and its photos and videos areas appeared on first use, and an archive copied or made by an older build could lack them. ArchiveStructure.Ensure (Core) creates the missing folders of BRIEF §7 idempotently, never touching existing folders or files, and reports why it could not (drive or share unavailable, permission denied, read-only, a file in the way) as one localized sentence. ArchiveService runs it when it creates an archive (refused with the reason when the tree cannot be made) and at every open. The server checks it at start-up and on each dashboard read: it logs a warning, the dashboard shows an "Archive incomplete" chip with the reason, and /health reports archive "incomplete". The desktop runs it when an archive is created, adopted or opened at start, and a folder typed in Settings that is not an archive yet becomes one in place, as Welcome's Create does; a writable archive whose tree cannot be completed is refused with the reason. Refs #31 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
181 lines
8.0 KiB
C#
181 lines
8.0 KiB
C#
using System.Security.AccessControl;
|
|
using System.Security.Principal;
|
|
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Core.Tests.Archiving;
|
|
|
|
[Category("archive")]
|
|
public sealed class ArchiveStructureTests(TestContext context)
|
|
{
|
|
private ArchivePaths NewArchive() => new(context.CreateTempDirectory("structure"));
|
|
|
|
[Test]
|
|
public void AnEmptyFolderGetsTheWholeLayout()
|
|
{
|
|
var archive = NewArchive();
|
|
|
|
var report = ArchiveStructure.Ensure(archive);
|
|
|
|
Assert.True(report.IsComplete);
|
|
Assert.Null(report.Message);
|
|
foreach (var folder in ArchiveStructure.Folders(archive)) Assert.True(Directory.Exists(folder), folder);
|
|
Assert.SequenceEqual(ArchiveStructure.Folders(archive).Skip(1), report.Created);
|
|
Assert.Empty(ArchiveStructure.Missing(archive));
|
|
string[] expected = [".chronos", ".chronos/locks", ".chronos/journal", ".chronos/staging", ".chronos/trash", ".chronos/trash/photos", ".chronos/trash/videos"];
|
|
Assert.SequenceEqual(expected, report.Created.Select(archive.ToRelative));
|
|
}
|
|
|
|
[Test]
|
|
public void AMissingRootIsCreatedOnlyForANewArchive()
|
|
{
|
|
var parent = context.CreateTempDirectory("parent");
|
|
var archive = new ArchivePaths(Path.Combine(parent, "Archive"));
|
|
|
|
var refused = ArchiveStructure.Ensure(archive);
|
|
Assert.Equal(ArchiveStructureProblem.Unavailable, refused.Problem);
|
|
Assert.Equal(archive.Root, refused.Folder);
|
|
Assert.False(Directory.Exists(archive.Root), "an archive that is not there is never made up");
|
|
|
|
var created = ArchiveStructure.Ensure(archive, createRoot: true);
|
|
Assert.True(created.IsComplete);
|
|
Assert.Equal(archive.Root, created.Created[0]);
|
|
Assert.Empty(ArchiveStructure.Missing(archive));
|
|
}
|
|
|
|
[Test]
|
|
public void AnExistingLayoutAndItsFilesAreLeftAsTheyAre()
|
|
{
|
|
var archive = NewArchive();
|
|
Assert.True(ArchiveStructure.Ensure(archive).IsComplete);
|
|
// Files where an archive keeps them, and the user's own: none may change, nor their times.
|
|
string[] files =
|
|
[
|
|
archive.ManifestPath,
|
|
Path.Combine(archive.TrashPhotosDirectory, "entry.json"),
|
|
Path.Combine(archive.StagingDirectory, "copy.tmp"),
|
|
Path.Combine(archive.Root, "2026", "Harbour", "originals", "IMG_0001.JPG"),
|
|
Path.Combine(archive.Root, "notes.txt"),
|
|
];
|
|
var written = new DateTime(2026, 1, 2, 3, 4, 5, DateTimeKind.Utc);
|
|
for (var i = 0; i < files.Length; i++)
|
|
{
|
|
Directory.CreateDirectory(Path.GetDirectoryName(files[i])!);
|
|
File.WriteAllBytes(files[i], [(byte)i, 1, 2, 3]);
|
|
File.SetLastWriteTimeUtc(files[i], written);
|
|
}
|
|
var folders = Directory.GetDirectories(archive.Root, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal).ToList();
|
|
|
|
var again = ArchiveStructure.Ensure(archive);
|
|
|
|
Assert.True(again.IsComplete);
|
|
Assert.Empty(again.Created);
|
|
for (var i = 0; i < files.Length; i++)
|
|
{
|
|
Assert.BytesEqual([(byte)i, 1, 2, 3], File.ReadAllBytes(files[i]));
|
|
Assert.Equal(written, File.GetLastWriteTimeUtc(files[i]));
|
|
}
|
|
Assert.SequenceEqual(folders, Directory.GetDirectories(archive.Root, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal));
|
|
}
|
|
|
|
[Test]
|
|
public void OnlyTheMissingFoldersAreCreated()
|
|
{
|
|
var archive = NewArchive();
|
|
Directory.CreateDirectory(archive.LocksDirectory);
|
|
File.WriteAllText(Path.Combine(archive.LocksDirectory, "lease"), "held");
|
|
|
|
var report = ArchiveStructure.Ensure(archive);
|
|
|
|
Assert.True(report.IsComplete);
|
|
Assert.False(report.Created.Contains(archive.MetaDirectory) || report.Created.Contains(archive.LocksDirectory));
|
|
Assert.True(report.Created.Contains(archive.TrashVideosDirectory));
|
|
Assert.Equal("held", File.ReadAllText(Path.Combine(archive.LocksDirectory, "lease")));
|
|
}
|
|
|
|
[Test]
|
|
public void AFileWhereAFolderBelongsIsReportedNotReplaced()
|
|
{
|
|
var archive = NewArchive();
|
|
Directory.CreateDirectory(archive.MetaDirectory);
|
|
File.WriteAllText(archive.TrashDirectory, "mine");
|
|
|
|
var report = ArchiveStructure.Ensure(archive);
|
|
|
|
Assert.Equal(ArchiveStructureProblem.Failed, report.Problem);
|
|
Assert.Equal(archive.TrashDirectory, report.Folder);
|
|
Assert.Equal("mine", File.ReadAllText(archive.TrashDirectory));
|
|
Assert.True(Directory.Exists(archive.StagingDirectory), "the folders before it are made");
|
|
Assert.Equal(Loc.L("Archive.Structure.Failed", archive.TrashDirectory), report.Message);
|
|
Assert.Equal(report.Message, new ArchiveStructureException(report).Message);
|
|
}
|
|
|
|
[Test]
|
|
public void EachFailureSaysWhy()
|
|
{
|
|
var archive = NewArchive();
|
|
(Exception Thrown, ArchiveStructureProblem Expected, string Key)[] cases =
|
|
[
|
|
(new UnauthorizedAccessException("denied"), ArchiveStructureProblem.Denied, "Archive.Structure.Denied"),
|
|
(new IOException("write protected", unchecked((int)0x80070013)), ArchiveStructureProblem.ReadOnly, "Archive.Structure.ReadOnly"),
|
|
(new IOException("not ready", unchecked((int)0x80070015)), ArchiveStructureProblem.Unavailable, "Archive.Structure.Unavailable"),
|
|
(new DirectoryNotFoundException("gone"), ArchiveStructureProblem.Unavailable, "Archive.Structure.Unavailable"),
|
|
(new IOException("disk full", unchecked((int)0x80070070)), ArchiveStructureProblem.Failed, "Archive.Structure.Failed"),
|
|
];
|
|
foreach (var (thrown, expected, key) in cases)
|
|
{
|
|
var report = ArchiveStructure.Ensure(archive, createDirectory: _ => throw thrown);
|
|
Assert.Equal(expected, report.Problem);
|
|
Assert.Equal(archive.MetaDirectory, report.Folder);
|
|
Assert.Equal(thrown.Message, report.Detail);
|
|
Assert.Empty(report.Created);
|
|
Assert.Equal(Loc.L(key, archive.MetaDirectory), report.Message);
|
|
}
|
|
Assert.False(Directory.Exists(archive.MetaDirectory));
|
|
if (!OperatingSystem.IsWindows())
|
|
Assert.Equal(ArchiveStructureProblem.ReadOnly, ArchiveStructure.Classify(new IOException("read-only file system", 30)));
|
|
}
|
|
|
|
[Test]
|
|
public void AFolderChronosMayNotWriteReportsTheError()
|
|
{
|
|
var archive = NewArchive();
|
|
if (OperatingSystem.IsWindows())
|
|
{
|
|
var info = new DirectoryInfo(archive.Root);
|
|
var me = WindowsIdentity.GetCurrent().User!;
|
|
var deny = new FileSystemAccessRule(me, FileSystemRights.CreateDirectories | FileSystemRights.CreateFiles, AccessControlType.Deny);
|
|
var security = info.GetAccessControl();
|
|
security.AddAccessRule(deny);
|
|
info.SetAccessControl(security);
|
|
try
|
|
{
|
|
var report = ArchiveStructure.Ensure(archive);
|
|
Assert.Equal(ArchiveStructureProblem.Denied, report.Problem);
|
|
Assert.Equal(archive.MetaDirectory, report.Folder);
|
|
Assert.False(Directory.Exists(archive.MetaDirectory));
|
|
}
|
|
finally
|
|
{
|
|
security.RemoveAccessRule(deny);
|
|
info.SetAccessControl(security);
|
|
}
|
|
return;
|
|
}
|
|
File.SetUnixFileMode(archive.Root, UnixFileMode.UserRead | UnixFileMode.UserExecute);
|
|
try
|
|
{
|
|
var report = ArchiveStructure.Ensure(archive);
|
|
// An account that ignores permissions (root in a CI container) writes anyway; the cases above cover the mapping.
|
|
if (report.IsComplete) Assert.Inconclusive("this account writes into read-only folders");
|
|
Assert.Equal(ArchiveStructureProblem.Denied, report.Problem);
|
|
Assert.Equal(archive.MetaDirectory, report.Folder);
|
|
}
|
|
finally
|
|
{
|
|
File.SetUnixFileMode(archive.Root, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
|
|
}
|
|
}
|
|
}
|