fix(app): a portable copy in a OneDrive folder keeps its index outside it
BRIEF §6.2 forbids a SQLite index in a synchronised folder. AppEnvironment.Detect now resolves the data folder through Core.Windows' AppPaths and OneDriveFolders: a portable copy whose .\data would lie under a OneDrive sync root (a OneDrive folder, or a Desktop or Documents folder backed up into one) keeps its data in %LOCALAPPDATA%\Titano and stays portable otherwise; AppEnvironment.SyncedFolder names the OneDrive folder so the user can be told. The pure choice lives in Core/IO/DataLocation (tested on Linux); reading the OneDrive accounts key no longer fails start-up when it cannot be read. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
12 files changed
+279
-53
No files matched your search
@@ -92,7 +92,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
|
||||
| Host | Composition root | What it runs |
|
||||
|---|---|---|
|
||||
| Titano (desktop) | `App/Infrastructure/AppServices` | SQLite index in `%LOCALAPPDATA%\Titano` (or `.\data` when portable); `ArchiveService` with WIC first, then managed decoders; `ProcessingService` with Media Foundation, then managed encoders; one `JobEngine` with the handlers of both; thumbnails; `ServerSession`; `SyncHost` while signed in (sync engine and agent, upload and download handlers, metered hold, editors of server sequences); the render node while opted in and signed in; update check and download (`About/UpdateCheck`, `About/UpdateDownload`, `About/UpdateFlow`: the setup, or the portable zip for a portable copy, verified against `SHA256SUMS`, resumable, cancellable, failing after 60 s without data); diagnostics bundle; daily index backups and the restore staged in Settings › Advanced (`DatabaseBackups`) |
|
||||
| Titano (desktop) | `App/Infrastructure/AppServices` | SQLite index in `%LOCALAPPDATA%\Titano` (or `.\data` when portable, unless the copy is in a OneDrive folder); `ArchiveService` with WIC first, then managed decoders; `ProcessingService` with Media Foundation, then managed encoders; one `JobEngine` with the handlers of both; thumbnails; `ServerSession`; `SyncHost` while signed in (sync engine and agent, upload and download handlers, metered hold, editors of server sequences); the render node while opted in and signed in; update check and download (`About/UpdateCheck`, `About/UpdateDownload`, `About/UpdateFlow`: the setup, or the portable zip for a portable copy, verified against `SHA256SUMS`, resumable, cancellable, failing after 60 s without data); diagnostics bundle; daily index backups and the restore staged in Settings › Advanced (`DatabaseBackups`) |
|
||||
| Titano Server | `Server/Hosting/ServerHost.Build` | Options from `server.json` + `TITANO_*`; PostgreSQL (or SQLite on Windows); `ArchiveModule` then `ProcessingModule` register job handler providers; `JobEngineHost` (renders only managed formats and MP4 jobs no render node can take, BRIEF §14.7); `RenderNodeService`/`RenderNodeMonitor`; `UploadService`; `EventHub` (WebSocket); embedded admin panel; LAN discovery beacon; Windows service host; daily backups of an SQLite index (`DatabaseBackupService`) |
|
||||
| Titano Uploader | `Uploader/App.xaml.cs` | `TitanoClient`, persisted queue, watch folders; no database |
|
||||
| Titano Setup | `Setup/Program` | TPK1 payload extraction, registry, shortcuts, file types named in setup's language, silent mode, uninstaller; only what starts a program its log or payload lists is changed: Windows services of those programs stopped once the programs have closed, started again (also after a failure) or deleted through the Service Control Manager (an elevated `/SERVICES … /NAMES` step when needed), sign-in entries of those programs removed, shared shortcuts handed to the product that keeps the program; the Server only for all users inside Program Files; "Remove my data" limited to the programs no other installed product uses |
|
||||
|
||||
@@ -45,6 +45,8 @@ public partial class App : Application
|
||||
// Capture runs in CI: mirror the log to stderr so failures are visible in the job output.
|
||||
Log.SetSink(capture ? new TeeLogSink(_log, new StderrLogSink()) : _log);
|
||||
Log.Info("app", $"Titano {AppServices.VersionText} starting; data at {Environment.DataDirectory}");
|
||||
// Settings tells the user once the window is up.
|
||||
if (Environment.SyncedFolder is { } synced) Log.Warning("app", $"This portable copy runs in the OneDrive folder {synced}: its data is kept outside it");
|
||||
|
||||
var projectFile = capture ? null : ProjectFileArgument(e.Args);
|
||||
if (!capture)
|
||||
|
||||
@@ -1,18 +1,22 @@
|
||||
using System.IO;
|
||||
using Titano.Core.Windows.Shell;
|
||||
|
||||
namespace Titano.App.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Where the client keeps its data (BRIEF §6.2): <c>%LOCALAPPDATA%\Titano</c>, or <c>.\data</c> next to the
|
||||
/// executable when <c>portable.txt</c> exists. Never inside Documents/OneDrive (SQLite corrupts in synced folders).
|
||||
/// Where the client keeps its data (BRIEF §6.2, <see cref="AppPaths"/>): <c>%LOCALAPPDATA%\Titano</c>, or <c>.\data</c>
|
||||
/// next to the executable when <c>portable.txt</c> exists. Never inside a folder OneDrive synchronises (SQLite corrupts
|
||||
/// there): a portable copy in one keeps its data in <c>%LOCALAPPDATA%\Titano</c>, and Settings tells the user so
|
||||
/// (<see cref="SyncedFolder"/>).
|
||||
/// </summary>
|
||||
public sealed class AppEnvironment
|
||||
{
|
||||
private AppEnvironment(string dataDirectory, bool portable, bool isCapture)
|
||||
private AppEnvironment(string dataDirectory, bool portable, bool isCapture, string? syncedFolder = null)
|
||||
{
|
||||
DataDirectory = dataDirectory;
|
||||
IsPortable = portable;
|
||||
IsCapture = isCapture;
|
||||
SyncedFolder = syncedFolder;
|
||||
Directory.CreateDirectory(DataDirectory);
|
||||
Directory.CreateDirectory(LogDirectory);
|
||||
Directory.CreateDirectory(CacheDirectory);
|
||||
@@ -24,20 +28,20 @@ public sealed class AppEnvironment
|
||||
/// <summary>A throw-away environment for <c>--capture</c>: nothing of the user's data is read or written.</summary>
|
||||
public bool IsCapture { get; }
|
||||
|
||||
/// <summary>The OneDrive folder this portable copy runs from; its data is in <c>%LOCALAPPDATA%\Titano</c> instead of <c>.\data</c>. Null otherwise.</summary>
|
||||
public string? SyncedFolder { get; }
|
||||
|
||||
public string LogDirectory => Path.Combine(DataDirectory, "logs");
|
||||
public string CacheDirectory => Path.Combine(DataDirectory, "cache");
|
||||
public string BackupDirectory => Path.Combine(DataDirectory, "backups");
|
||||
public string DatabasePath => Path.Combine(DataDirectory, "titano.db");
|
||||
public string SettingsPath => Path.Combine(DataDirectory, "settings.json");
|
||||
|
||||
public static AppEnvironment Detect()
|
||||
{
|
||||
var exeDir = AppContext.BaseDirectory;
|
||||
if (File.Exists(Path.Combine(exeDir, "portable.txt")))
|
||||
return new AppEnvironment(Path.Combine(exeDir, "data"), portable: true, isCapture: false);
|
||||
var local = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
||||
return new AppEnvironment(Path.Combine(local, "Titano"), portable: false, isCapture: false);
|
||||
}
|
||||
/// <summary>The environment of this process: its executable's folder and the user's OneDrive folders decide.</summary>
|
||||
public static AppEnvironment Detect() => From(AppPaths.Resolve());
|
||||
|
||||
/// <summary>The environment at <paramref name="paths"/> (its folders are created).</summary>
|
||||
public static AppEnvironment From(AppPaths paths) => new(paths.DataRoot, paths.IsPortable, isCapture: false, paths.PortableSyncRoot);
|
||||
|
||||
/// <summary>A fresh temporary data folder for screenshots and smoke tests; delete it with <see cref="DeleteCaptureData"/>.</summary>
|
||||
public static AppEnvironment ForCapture() =>
|
||||
|
||||
@@ -1,22 +1,28 @@
|
||||
using Titano.Core.IO;
|
||||
|
||||
namespace Titano.Core.Windows.Shell;
|
||||
|
||||
/// <summary>
|
||||
/// Where the desktop programs keep their data (BRIEF §6.2): <c>%LOCALAPPDATA%\Titano</c>, or <c>.\data</c> next to the
|
||||
/// executable in portable mode. SQLite corrupts inside synchronised folders, so a data root under OneDrive is
|
||||
/// reported by <see cref="SyncedFolder"/> and refused by <see cref="CreateDirectories"/>.
|
||||
/// Where the desktop programs keep their data (BRIEF §6.2, <see cref="DataLocation"/>): <c>%LOCALAPPDATA%\Titano</c>, or
|
||||
/// <c>.\data</c> next to the executable in portable mode. SQLite corrupts inside synchronised folders, so a portable
|
||||
/// copy in a OneDrive folder keeps its data in <c>%LOCALAPPDATA%\Titano</c> instead (<see cref="PortableSyncRoot"/>
|
||||
/// names that folder to tell the user), and a data root still under OneDrive is reported by <see cref="SyncedFolder"/>
|
||||
/// and refused by <see cref="CreateDirectories"/>.
|
||||
/// </summary>
|
||||
public sealed class AppPaths
|
||||
{
|
||||
public const string ProductFolderName = "Titano";
|
||||
public const string ProductFolderName = DataLocation.ProductFolderName;
|
||||
public const string DatabaseFileName = "titano.db";
|
||||
|
||||
private AppPaths(string dataRoot, bool isPortable, string? syncedFolder)
|
||||
private AppPaths(DataLocation location)
|
||||
{
|
||||
DataRoot = dataRoot;
|
||||
IsPortable = isPortable;
|
||||
SyncedFolder = syncedFolder;
|
||||
DataRoot = location.Root;
|
||||
IsPortable = location.IsPortable;
|
||||
SyncedFolder = location.SyncedFolder;
|
||||
PortableSyncRoot = location.PortableSyncRoot;
|
||||
}
|
||||
|
||||
/// <summary>A portable copy, also when its data had to go to <c>%LOCALAPPDATA%\Titano</c>.</summary>
|
||||
public bool IsPortable { get; }
|
||||
|
||||
public string DataRoot { get; }
|
||||
@@ -34,6 +40,9 @@ public sealed class AppPaths
|
||||
|
||||
public bool IsInSyncedFolder => SyncedFolder is not null;
|
||||
|
||||
/// <summary>The OneDrive sync root a portable copy runs from, whose data is in <c>%LOCALAPPDATA%\Titano</c> instead; null otherwise.</summary>
|
||||
public string? PortableSyncRoot { get; }
|
||||
|
||||
/// <summary>Paths for this process: the executable's folder decides portable mode.</summary>
|
||||
public static AppPaths Resolve() => Resolve(AppContext.BaseDirectory, KnownFolders.LocalAppData);
|
||||
|
||||
@@ -41,14 +50,9 @@ public sealed class AppPaths
|
||||
public static AppPaths Resolve(string applicationDirectory, string localAppData) =>
|
||||
Resolve(applicationDirectory, localAppData, OneDriveFolders.SyncRoots());
|
||||
|
||||
internal static AppPaths Resolve(string applicationDirectory, string localAppData, IReadOnlyList<string> syncRoots)
|
||||
{
|
||||
var portable = PortableMode.IsEnabled(applicationDirectory);
|
||||
var root = Path.GetFullPath(portable
|
||||
? Path.Combine(applicationDirectory, PortableMode.DataFolderName)
|
||||
: Path.Combine(localAppData, ProductFolderName));
|
||||
return new AppPaths(root, portable, OneDriveFolders.Containing(root, syncRoots));
|
||||
}
|
||||
/// <summary>Paths for an executable in <paramref name="applicationDirectory"/>, checked against <paramref name="syncRoots"/>.</summary>
|
||||
public static AppPaths Resolve(string applicationDirectory, string localAppData, IReadOnlyCollection<string> syncRoots) =>
|
||||
new(DataLocation.Choose(applicationDirectory, PortableMode.IsEnabled(applicationDirectory), localAppData, syncRoots));
|
||||
|
||||
/// <summary>Creates the data, logs, cache and thumbnails folders.</summary>
|
||||
/// <exception cref="InvalidOperationException">The data root lies inside a OneDrive-synced folder.</exception>
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
using System.Security;
|
||||
using Microsoft.Win32;
|
||||
using Titano.Core.IO;
|
||||
|
||||
namespace Titano.Core.Windows.Shell;
|
||||
|
||||
@@ -10,34 +12,34 @@ public static class OneDriveFolders
|
||||
|
||||
/// <summary>
|
||||
/// Sync roots from the OneDrive environment variables and <c>HKCU\Software\Microsoft\OneDrive\Accounts\*\UserFolder</c>,
|
||||
/// as full paths without a trailing separator, distinct (case-insensitive).
|
||||
/// as full paths without a trailing separator, distinct (case-insensitive). An account key that cannot be read is
|
||||
/// skipped: the programs start all the same.
|
||||
/// </summary>
|
||||
public static IReadOnlyList<string> SyncRoots()
|
||||
{
|
||||
var roots = new List<string>();
|
||||
foreach (var variable in EnvironmentVariables) Add(roots, Environment.GetEnvironmentVariable(variable));
|
||||
using var accounts = Registry.CurrentUser.OpenSubKey(AccountsKey);
|
||||
if (accounts is not null)
|
||||
try
|
||||
{
|
||||
foreach (var name in accounts.GetSubKeyNames())
|
||||
using var accounts = Registry.CurrentUser.OpenSubKey(AccountsKey);
|
||||
if (accounts is not null)
|
||||
{
|
||||
using var account = accounts.OpenSubKey(name);
|
||||
Add(roots, account?.GetValue("UserFolder") as string);
|
||||
foreach (var name in accounts.GetSubKeyNames())
|
||||
{
|
||||
using var account = accounts.OpenSubKey(name);
|
||||
Add(roots, account?.GetValue("UserFolder") as string);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is SecurityException or IOException or UnauthorizedAccessException)
|
||||
{
|
||||
// The environment variables name the usual roots.
|
||||
}
|
||||
return roots;
|
||||
}
|
||||
|
||||
/// <summary>The sync root that contains <paramref name="path"/>, or null. Both are expected to be full paths.</summary>
|
||||
public static string? Containing(string path, IEnumerable<string> syncRoots) => syncRoots.FirstOrDefault(root => IsUnder(path, root));
|
||||
|
||||
/// <summary>True when <paramref name="path"/> equals <paramref name="root"/> or lies below it (whole path segments, case-insensitive).</summary>
|
||||
internal static bool IsUnder(string path, string root)
|
||||
{
|
||||
var trimmedRoot = root.TrimEnd('\\', '/');
|
||||
if (trimmedRoot.Length == 0 || !path.StartsWith(trimmedRoot, StringComparison.OrdinalIgnoreCase)) return false;
|
||||
return path.Length == trimmedRoot.Length || path[trimmedRoot.Length] is '\\' or '/';
|
||||
}
|
||||
public static string? Containing(string path, IEnumerable<string> syncRoots) => DataLocation.SyncRootOf(path, syncRoots);
|
||||
|
||||
private static void Add(List<string> roots, string? candidate)
|
||||
{
|
||||
|
||||
@@ -1,10 +1,12 @@
|
||||
using Titano.Core.IO;
|
||||
|
||||
namespace Titano.Core.Windows.Shell;
|
||||
|
||||
/// <summary>Portable mode (BRIEF §6.2): a <c>portable.txt</c> next to the executable keeps all data under <c>.\data\</c>.</summary>
|
||||
public static class PortableMode
|
||||
{
|
||||
public const string MarkerFileName = "portable.txt";
|
||||
public const string DataFolderName = "data";
|
||||
public const string DataFolderName = DataLocation.PortableFolderName;
|
||||
|
||||
public static bool IsEnabled(string applicationDirectory) => File.Exists(Path.Combine(applicationDirectory, MarkerFileName));
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
namespace Titano.Core.IO;
|
||||
|
||||
/// <summary>
|
||||
/// Where the desktop client keeps its data (BRIEF §6.2): the per-user folder (<c>%LOCALAPPDATA%\Titano</c>), or
|
||||
/// <c>.\data</c> next to the executable of a portable copy (a <c>portable.txt</c> beside it). SQLite corrupts inside
|
||||
/// synchronised folders, so a portable copy in a folder OneDrive synchronises (a OneDrive folder, or a Desktop or
|
||||
/// Documents folder moved into one) keeps its data in the per-user folder instead, and <see cref="PortableSyncRoot"/>
|
||||
/// says so, to tell the user. Paths are full paths; a folder lies in a sync root when its whole leading segments are
|
||||
/// that root's, ignoring case as Windows does.
|
||||
/// </summary>
|
||||
/// <param name="Root">The data folder.</param>
|
||||
/// <param name="IsPortable">The copy is portable, also when its data had to go to the per-user folder.</param>
|
||||
/// <param name="SyncedFolder">The sync root that contains <paramref name="Root"/> itself; null when the data is safe there.</param>
|
||||
/// <param name="PortableSyncRoot">The sync root a portable copy runs from, whose data went to the per-user folder instead; null otherwise.</param>
|
||||
public sealed record DataLocation(string Root, bool IsPortable, string? SyncedFolder, string? PortableSyncRoot)
|
||||
{
|
||||
/// <summary>The data folder's name under the user's local application data.</summary>
|
||||
public const string ProductFolderName = "Titano";
|
||||
|
||||
/// <summary>The data folder's name next to a portable copy's executable.</summary>
|
||||
public const string PortableFolderName = "data";
|
||||
|
||||
/// <summary>
|
||||
/// The data folder of a copy in <paramref name="applicationDirectory"/> (<paramref name="portable"/> when it has a
|
||||
/// <c>portable.txt</c>), given the user's local application data and the OneDrive sync roots.
|
||||
/// </summary>
|
||||
public static DataLocation Choose(string applicationDirectory, bool portable, string localAppData, IReadOnlyCollection<string> syncRoots)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(applicationDirectory);
|
||||
ArgumentNullException.ThrowIfNull(localAppData);
|
||||
ArgumentNullException.ThrowIfNull(syncRoots);
|
||||
var perUser = Path.GetFullPath(Path.Combine(localAppData, ProductFolderName));
|
||||
if (!portable) return new DataLocation(perUser, false, SyncRootOf(perUser, syncRoots), null);
|
||||
var beside = Path.GetFullPath(Path.Combine(applicationDirectory, PortableFolderName));
|
||||
return SyncRootOf(beside, syncRoots) is { } synced
|
||||
? new DataLocation(perUser, true, SyncRootOf(perUser, syncRoots), synced)
|
||||
: new DataLocation(beside, true, null, null);
|
||||
}
|
||||
|
||||
/// <summary>The sync root that contains <paramref name="path"/>, or null.</summary>
|
||||
public static string? SyncRootOf(string path, IEnumerable<string> syncRoots) => syncRoots.FirstOrDefault(root => IsUnder(path, root));
|
||||
|
||||
/// <summary>True when <paramref name="path"/> equals <paramref name="root"/> or lies below it (whole path segments, case-insensitive).</summary>
|
||||
public static bool IsUnder(string path, string root)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(path);
|
||||
ArgumentNullException.ThrowIfNull(root);
|
||||
var trimmedRoot = root.TrimEnd('\\', '/');
|
||||
if (trimmedRoot.Length == 0 || !path.StartsWith(trimmedRoot, StringComparison.OrdinalIgnoreCase)) return false;
|
||||
return path.Length == trimmedRoot.Length || path[trimmedRoot.Length] is '\\' or '/';
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,8 @@ namespace Titano.Uploader.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Where the uploader keeps its files: <c>%LOCALAPPDATA%\Titano</c> (shared with the client), or <c>.\data</c> next
|
||||
/// to the executable when <c>portable.txt</c> exists — the same rule as the desktop client.
|
||||
/// to the executable when <c>portable.txt</c> exists — the desktop client's rule, except that the client never keeps
|
||||
/// its SQLite index in a folder OneDrive synchronises; the Uploader's JSON files, written atomically, stay there.
|
||||
/// </summary>
|
||||
public sealed class UploaderEnvironment
|
||||
{
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
using System.IO;
|
||||
using Titano.App.Infrastructure;
|
||||
using Titano.Core.Windows.Shell;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.App.Tests.Infrastructure;
|
||||
|
||||
/// <summary>BRIEF §6.2: the client's data folder, which is never inside a folder OneDrive synchronises.</summary>
|
||||
public sealed class AppEnvironmentTests(TestContext context)
|
||||
{
|
||||
[Test]
|
||||
public void APortableCopyInOneDriveKeepsItsDataInTheUserFolderAndSaysSo()
|
||||
{
|
||||
var oneDrive = context.CreateTempDirectory("onedrive");
|
||||
var app = Directory.CreateDirectory(Path.Combine(oneDrive, "Desktop", "Titano")).FullName;
|
||||
File.WriteAllText(Path.Combine(app, PortableMode.MarkerFileName), "");
|
||||
var local = context.CreateTempDirectory("local");
|
||||
|
||||
var environment = AppEnvironment.From(AppPaths.Resolve(app, local, [oneDrive]));
|
||||
|
||||
Assert.Equal(Path.Combine(local, "Titano", "titano.db"), environment.DatabasePath);
|
||||
Assert.True(environment.IsPortable, "still a portable copy: updates fetch the portable zip, no sign-in entry");
|
||||
Assert.Equal<string?>(oneDrive, environment.SyncedFolder);
|
||||
Assert.True(Directory.Exists(environment.LogDirectory));
|
||||
Assert.False(Directory.Exists(Path.Combine(app, "data")), "nothing is written into the synchronised folder");
|
||||
|
||||
// Elsewhere (a USB stick) a portable copy keeps its data beside it.
|
||||
var stick = context.CreateTempDirectory("stick");
|
||||
File.WriteAllText(Path.Combine(stick, PortableMode.MarkerFileName), "");
|
||||
var beside = AppEnvironment.From(AppPaths.Resolve(stick, local, [oneDrive]));
|
||||
Assert.Equal(Path.Combine(stick, "data"), beside.DataDirectory);
|
||||
Assert.Null(beside.SyncedFolder);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
using Titano.Core.IO;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.Core.Tests.Foundation;
|
||||
|
||||
/// <summary>BRIEF §6.2: where the client keeps its index, and never inside a folder OneDrive synchronises.</summary>
|
||||
public sealed class DataLocationTests(TestContext context)
|
||||
{
|
||||
[Test]
|
||||
public void AnInstalledCopyUsesThePerUserFolderAndAPortableOneItsOwn()
|
||||
{
|
||||
var app = context.CreateTempDirectory("app");
|
||||
var local = context.CreateTempDirectory("local");
|
||||
|
||||
var installed = DataLocation.Choose(app, portable: false, local, []);
|
||||
Assert.Equal(new DataLocation(Path.Combine(local, "Titano"), false, null, null), installed);
|
||||
|
||||
var portable = DataLocation.Choose(app, portable: true, local, []);
|
||||
Assert.Equal(new DataLocation(Path.Combine(app, "data"), true, null, null), portable);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void APortableCopyInASynchronisedFolderKeepsItsDataInThePerUserFolder()
|
||||
{
|
||||
// A portable copy unpacked on a Desktop that OneDrive's folder backup moved into the sync root.
|
||||
var oneDrive = context.CreateTempDirectory("onedrive");
|
||||
var app = Path.Combine(oneDrive, "Desktop", "Titano");
|
||||
var local = context.CreateTempDirectory("local");
|
||||
|
||||
var location = DataLocation.Choose(app, portable: true, local, [Path.Combine(context.CreateTempDirectory("other"), "OneDrive"), oneDrive]);
|
||||
|
||||
Assert.Equal(Path.Combine(local, "Titano"), location.Root);
|
||||
Assert.True(location.IsPortable, "still a portable copy (updates, no sign-in entry)");
|
||||
Assert.Equal<string?>(oneDrive, location.PortableSyncRoot);
|
||||
Assert.Null(location.SyncedFolder);
|
||||
|
||||
// A sync root that only shares the start of the name is another folder.
|
||||
var beside = DataLocation.Choose(oneDrive + "Backup", portable: true, local, [oneDrive]);
|
||||
Assert.Equal(new DataLocation(Path.Combine(oneDrive + "Backup", "data"), true, null, null), beside);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void APerUserFolderInsideASyncRootIsReported()
|
||||
{
|
||||
var oneDrive = context.CreateTempDirectory("onedrive");
|
||||
var local = Path.Combine(oneDrive, "AppData", "Local");
|
||||
|
||||
var installed = DataLocation.Choose(context.CreateTempDirectory("app"), portable: false, local, [oneDrive]);
|
||||
Assert.Equal<string?>(oneDrive, installed.SyncedFolder);
|
||||
|
||||
var portable = DataLocation.Choose(Path.Combine(oneDrive, "Titano"), portable: true, local, [oneDrive]);
|
||||
Assert.Equal<(string, string?, string?)>((Path.Combine(local, "Titano"), oneDrive, oneDrive), (portable.Root, portable.SyncedFolder, portable.PortableSyncRoot));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void SyncRootMatchingIsSegmentWiseAndIgnoresCase()
|
||||
{
|
||||
var root = Path.Combine(context.CreateTempDirectory(), "OneDrive");
|
||||
Assert.True(DataLocation.IsUnder(root, root));
|
||||
Assert.True(DataLocation.IsUnder(Path.Combine(root, "Pictures"), root + Path.DirectorySeparatorChar));
|
||||
Assert.True(DataLocation.IsUnder(Path.Combine(root, "x").ToUpperInvariant(), root));
|
||||
Assert.True(DataLocation.IsUnder(@"C:\Users\ada\OneDrive\Desktop\Titano\data", @"c:\users\ada\onedrive"), "Windows paths on any platform");
|
||||
Assert.False(DataLocation.IsUnder(root + "Backup", root));
|
||||
Assert.False(DataLocation.IsUnder(root, string.Empty));
|
||||
Assert.Null(DataLocation.SyncRootOf(root + "Backup", [root]));
|
||||
Assert.Equal<string?>(root, DataLocation.SyncRootOf(Path.Combine(root, "Documents"), ["", root]));
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,7 @@ public sealed class AppPathsTests(TestContext context)
|
||||
Assert.Equal(Path.Combine(app, "data"), paths.DataRoot);
|
||||
Assert.Equal(Path.Combine(app, "data", "titano.db"), paths.DatabasePath);
|
||||
Assert.False(paths.IsInSyncedFolder);
|
||||
Assert.Null(paths.PortableSyncRoot);
|
||||
|
||||
paths.CreateDirectories();
|
||||
Assert.True(Directory.Exists(paths.LogsDirectory));
|
||||
@@ -37,13 +38,31 @@ public sealed class AppPathsTests(TestContext context)
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DataInsideOneDriveIsReportedAndRefused()
|
||||
public void APortableCopyInOneDriveKeepsItsDataInLocalAppData()
|
||||
{
|
||||
var oneDrive = context.CreateTempDirectory("onedrive");
|
||||
var app = Directory.CreateDirectory(Path.Combine(oneDrive, "Tools", "Titano")).FullName;
|
||||
File.WriteAllText(Path.Combine(app, PortableMode.MarkerFileName), "");
|
||||
var local = context.CreateTempDirectory("local");
|
||||
|
||||
var paths = AppPaths.Resolve(app, context.CreateTempDirectory("local"), [oneDrive]);
|
||||
var paths = AppPaths.Resolve(app, local, [oneDrive]);
|
||||
Assert.True(paths.IsPortable);
|
||||
Assert.Equal(Path.Combine(local, "Titano"), paths.DataRoot);
|
||||
Assert.Equal<string?>(oneDrive, paths.PortableSyncRoot);
|
||||
Assert.False(paths.IsInSyncedFolder);
|
||||
paths.CreateDirectories();
|
||||
Assert.True(Directory.Exists(paths.LogsDirectory));
|
||||
Assert.False(Directory.Exists(Path.Combine(app, "data")), "nothing is written into the synchronised folder");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void DataInsideOneDriveIsReportedAndRefused()
|
||||
{
|
||||
// Local application data inside a sync root: nowhere is safe, so nothing is created.
|
||||
var oneDrive = context.CreateTempDirectory("onedrive");
|
||||
var local = Directory.CreateDirectory(Path.Combine(oneDrive, "AppData", "Local")).FullName;
|
||||
|
||||
var paths = AppPaths.Resolve(context.CreateTempDirectory("app"), local, [oneDrive]);
|
||||
Assert.True(paths.IsInSyncedFolder);
|
||||
Assert.Equal<string?>(oneDrive, paths.SyncedFolder);
|
||||
Assert.Throws<InvalidOperationException>(paths.CreateDirectories);
|
||||
@@ -54,10 +73,7 @@ public sealed class AppPathsTests(TestContext context)
|
||||
public void SyncRootMatchingIsSegmentWise()
|
||||
{
|
||||
var root = Path.Combine(context.CreateTempDirectory(), "OneDrive");
|
||||
Assert.True(OneDriveFolders.IsUnder(root, root));
|
||||
Assert.True(OneDriveFolders.IsUnder(Path.Combine(root, "Pictures"), root + Path.DirectorySeparatorChar));
|
||||
Assert.True(OneDriveFolders.IsUnder(Path.Combine(root, "x").ToUpperInvariant(), root));
|
||||
Assert.False(OneDriveFolders.IsUnder(root + "Backup", root));
|
||||
Assert.Equal<string?>(root, OneDriveFolders.Containing(Path.Combine(root, "Pictures"), [root]));
|
||||
Assert.Null(OneDriveFolders.Containing(root + "Backup", [root]));
|
||||
}
|
||||
|
||||
@@ -68,8 +84,10 @@ public sealed class AppPathsTests(TestContext context)
|
||||
var app = context.CreateTempDirectory("app");
|
||||
File.WriteAllText(Path.Combine(app, PortableMode.MarkerFileName), "");
|
||||
var paths = AppPaths.Resolve(app, KnownFolders.LocalAppData);
|
||||
var roots = OneDriveFolders.SyncRoots();
|
||||
Assert.True(paths.IsPortable);
|
||||
Assert.Equal(OneDriveFolders.Containing(paths.DataRoot, OneDriveFolders.SyncRoots()), paths.SyncedFolder);
|
||||
Assert.True(OneDriveFolders.SyncRoots().All(Path.IsPathFullyQualified));
|
||||
Assert.Equal(OneDriveFolders.Containing(Path.Combine(app, PortableMode.DataFolderName), roots), paths.PortableSyncRoot);
|
||||
Assert.Equal(OneDriveFolders.Containing(paths.DataRoot, roots), paths.SyncedFolder);
|
||||
Assert.True(roots.All(Path.IsPathFullyQualified));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
using Titano.Core.Windows.Shell;
|
||||
using Titano.Testing;
|
||||
|
||||
namespace Titano.Core.Windows.Tests.Shell;
|
||||
|
||||
/// <summary>The OneDrive folders of the user as Windows reports them. Serial: a test sets a process environment variable.</summary>
|
||||
[Serial]
|
||||
public sealed class OneDriveFoldersTests(TestContext context)
|
||||
{
|
||||
private const string Variable = "OneDriveCommercial";
|
||||
|
||||
[Test]
|
||||
[WindowsOnly]
|
||||
public void APortableCopyInTheUsersOneDriveKeepsItsDataInLocalAppData()
|
||||
{
|
||||
var oneDrive = context.CreateTempDirectory("onedrive");
|
||||
var previous = Environment.GetEnvironmentVariable(Variable);
|
||||
Environment.SetEnvironmentVariable(Variable, oneDrive);
|
||||
try
|
||||
{
|
||||
Assert.Contains(OneDriveFolders.SyncRoots(), root => string.Equals(root, Path.TrimEndingDirectorySeparator(oneDrive), StringComparison.OrdinalIgnoreCase));
|
||||
// A Desktop that OneDrive's folder backup moved into the sync root, with a portable copy unpacked on it.
|
||||
var app = Directory.CreateDirectory(Path.Combine(oneDrive, "Desktop", "Titano")).FullName;
|
||||
File.WriteAllText(Path.Combine(app, PortableMode.MarkerFileName), "");
|
||||
var local = context.CreateTempDirectory("local");
|
||||
|
||||
var paths = AppPaths.Resolve(app, local);
|
||||
|
||||
Assert.True(paths.IsPortable);
|
||||
Assert.Equal(Path.Combine(local, AppPaths.ProductFolderName), paths.DataRoot);
|
||||
Assert.NotNull(paths.PortableSyncRoot);
|
||||
Assert.False(paths.IsInSyncedFolder);
|
||||
}
|
||||
finally
|
||||
{
|
||||
Environment.SetEnvironmentVariable(Variable, previous);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user