CI / Build and test (push) Successful in 10m37s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 9s
Release / Build, test and publish (push) Successful in 16m19s
CI / PostgreSQL 16 integration (push) Successful in 10m19s
CI / PostgreSQL 17 integration (push) Successful in 11m27s
CI / Docker image (push) Successful in 57s
Release / Server image (push) Successful in 1m34s
Owner review 4 and owner review 1 phase 6. - Work board in Videos (desktop and admin panel): Published and Workspace lanes (#29). - Anonymous usage counts removed: Chronos sends nothing about its use (#30). - The archive's whole folder tree is created inside any archive root, on the server and the desktop (#31). - Video cards start with the preset; sizes keep number and unit together (#28). - Deploy guide docs/deploy (Docker, Unraid, desktop), BRIEF §24, original documentation in docs/reference/original (#22). Closes #22 #28 #29 #30 #31 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.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);
|
|
}
|
|
}
|
|
}
|