Files
Alby96andClaude Opus 5.5 0075065884
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
feat: work board, no usage data, archive folder tree, deploy guide (owner review 4 + owner review 1 phase 6) (#62)
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>
2026-11-06 18:46:22 +01:00

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);
}
}
}