feat: add storage foundation and i18n resources

YKanBan.Tests/Storage/Workspace/WorkspaceInitializerTests.cs

@@ -0,0 +1,64 @@
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>
+/// Tests for workspace detection and initialization. Initialization creates
+/// the structure and an empty migrated database, but deliberately adds no
+/// content.
+/// </summary>
+[TestClass]
+public class WorkspaceInitializerTests
+{
+    [TestMethod]
+    public void IsWorkspaceReflectsInitializationState()
+    {
+        using var directory = new TempDirectory();
+        Assert.IsFalse(WorkspaceInitializer.IsWorkspace(directory.FullPath));
+
+        WorkspaceInitializer.Initialize(directory.FullPath);
+        Assert.IsTrue(WorkspaceInitializer.IsWorkspace(directory.FullPath));
+    }
+
+    [TestMethod]
+    public void InitializeCreatesStructureAndMigratedEmptyDatabase()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        Assert.IsTrue(Directory.Exists(WorkspacePaths.Root(directory.FullPath)));
+        Assert.IsTrue(File.Exists(WorkspacePaths.Database(directory.FullPath)));
+
+        using SqliteConnection connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+        Assert.AreEqual(WorkspaceSchema.CurrentVersion, SqliteDatabase.ReadUserVersion(connection));
+        Assert.IsTrue(SqliteTestHelper.TableExists(connection, "columns"));
+        Assert.IsTrue(SqliteTestHelper.TableExists(connection, "cards"));
+        Assert.IsTrue(SqliteTestHelper.TableExists(connection, "tags"));
+        Assert.IsTrue(SqliteTestHelper.TableExists(connection, "card_tags"));
+        // Initialization does not add preset content.
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM columns;"));
+    }
+
+    [TestMethod]
+    public void InitializeMissingFolderThrows()
+    {
+        using var directory = new TempDirectory();
+        string missing = Path.Combine(directory.FullPath, "not-created");
+
+        WorkspaceDirectoryMissingException exception = Assert.ThrowsExactly<WorkspaceDirectoryMissingException>(
+            () => WorkspaceInitializer.Initialize(missing));
+        Assert.AreEqual(missing, exception.FolderPath);
+    }
+
+    [TestMethod]
+    public void InitializeTwiceThrows()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        Assert.ThrowsExactly<InvalidOperationException>(() => WorkspaceInitializer.Initialize(directory.FullPath));
+    }
+}

YKanBan.Tests/Storage/Workspace/WorkspaceLockTests.cs

@@ -0,0 +1,59 @@
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>
+/// Tests for exclusive lock acquisition, diagnostics and release.
+/// </summary>
+[TestClass]
+public class WorkspaceLockTests
+{
+    [TestMethod]
+    public void AcquireThenDisposeThenAcquireAgainSucceeds()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        WorkspaceLock.Acquire(directory.FullPath).Dispose();
+        // Re-acquiring after release works: no stale lock residue survives.
+        WorkspaceLock.Acquire(directory.FullPath).Dispose();
+    }
+
+    [TestMethod]
+    public void SecondAcquireWhileHeldThrows()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        using WorkspaceLock first = WorkspaceLock.Acquire(directory.FullPath);
+        WorkspaceLockException exception = Assert.ThrowsExactly<WorkspaceLockException>(
+            () => WorkspaceLock.Acquire(directory.FullPath));
+        Assert.AreEqual(WorkspacePaths.LockFile(directory.FullPath), exception.LockFilePath);
+    }
+
+    [TestMethod]
+    public void AcquireWithoutYkanbanThrowsNotInitialized()
+    {
+        using var directory = new TempDirectory();
+        Assert.ThrowsExactly<WorkspaceNotInitializedException>(
+            () => WorkspaceLock.Acquire(directory.FullPath));
+    }
+
+    [TestMethod]
+    public void LockFileContainsHolderDiagnosticsAfterRelease()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        using (WorkspaceLock.Acquire(directory.FullPath))
+        {
+        }
+
+        // The file survives release and carries PID / machine name / time for humans.
+        string content = File.ReadAllText(WorkspacePaths.LockFile(directory.FullPath));
+        StringAssert.Contains(content, "pid=");
+        StringAssert.Contains(content, $"machine={Environment.MachineName}");
+    }
+}

YKanBan.Tests/Storage/Workspace/WorkspacePresetTests.cs

@@ -0,0 +1,99 @@
+using System.Globalization;
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>
+/// Verifies that the preset column titles follow the UI language active when
+/// they are added and then live as ordinary data. These tests mutate the
+/// global <see cref="Resources.Culture"/>, so they are marked do-not-parallelize.
+/// </summary>
+[TestClass]
+[DoNotParallelize]
+public class WorkspacePresetTests
+{
+    [TestMethod]
+    public void AddPresetColumnsStoresEnglishTitlesUnderEnglishCulture()
+    {
+        CultureInfo? original = Resources.Culture;
+        try
+        {
+            Resources.Culture = new CultureInfo("en");
+            string[] expected =
+            [
+                Resources.PresetColumn_Todo,
+                Resources.PresetColumn_InProgress,
+                Resources.PresetColumn_Done,
+            ];
+
+            using var directory = new TempDirectory();
+            WorkspaceInitializer.Initialize(directory.FullPath);
+            WorkspacePreset.AddPresetColumns(directory.FullPath);
+
+            using SqliteConnection connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+            CollectionAssert.AreEqual(expected, SqliteTestHelper.GetColumnTitles(connection));
+        }
+        finally
+        {
+            Resources.Culture = original;
+        }
+    }
+
+    [TestMethod]
+    public void AddPresetColumnsStoresChineseTitlesUnderChineseCulture()
+    {
+        CultureInfo? original = Resources.Culture;
+        try
+        {
+            Resources.Culture = new CultureInfo("zh-Hans");
+            string[] expected =
+            [
+                Resources.PresetColumn_Todo,
+                Resources.PresetColumn_InProgress,
+                Resources.PresetColumn_Done,
+            ];
+
+            using var directory = new TempDirectory();
+            WorkspaceInitializer.Initialize(directory.FullPath);
+            WorkspacePreset.AddPresetColumns(directory.FullPath);
+
+            using SqliteConnection connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+            CollectionAssert.AreEqual(expected, SqliteTestHelper.GetColumnTitles(connection));
+        }
+        finally
+        {
+            Resources.Culture = original;
+        }
+    }
+
+    [TestMethod]
+    public void PresetTitlesAreDataAndIgnoreLaterCultureChanges()
+    {
+        CultureInfo? original = Resources.Culture;
+        try
+        {
+            Resources.Culture = new CultureInfo("en");
+            string[] expected =
+            [
+                Resources.PresetColumn_Todo,
+                Resources.PresetColumn_InProgress,
+                Resources.PresetColumn_Done,
+            ];
+
+            using var directory = new TempDirectory();
+            WorkspaceInitializer.Initialize(directory.FullPath);
+            WorkspacePreset.AddPresetColumns(directory.FullPath);
+
+            // Switching the language after adding the presets must not rewrite stored data.
+            Resources.Culture = new CultureInfo("zh-Hans");
+            using SqliteConnection connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+            CollectionAssert.AreEqual(expected, SqliteTestHelper.GetColumnTitles(connection));
+        }
+        finally
+        {
+            Resources.Culture = original;
+        }
+    }
+}

YKanBan.Tests/Storage/Workspace/WorkspaceSchemaTests.cs

@@ -0,0 +1,224 @@
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>
+/// Verifies that the workspace DDL constraints reject invalid data at the door
+/// and that the cascading delete chains work as specified.
+/// </summary>
+[TestClass]
+public class WorkspaceSchemaTests
+{
+    /// <summary>
+    /// Owns a temp directory plus a fresh workspace-schema database for a single test.
+    /// </summary>
+    private sealed class FreshDatabase : IDisposable
+    {
+        public TempDirectory Directory { get; } = new();
+
+        public SqliteConnection Connection { get; }
+
+        public FreshDatabase()
+        {
+            Connection = SqliteDatabase.Open(
+                Path.Combine(Directory.FullPath, "ws.db"), WorkspaceSchema.Migrations);
+        }
+
+        /// <summary>
+        /// Closes the connection before removing the temporary directory.
+        /// </summary>
+        public void Dispose()
+        {
+            Connection.Dispose();
+            Directory.Dispose();
+        }
+    }
+
+    [TestMethod]
+    public void EmptyColumnTitleIsRejected()
+    {
+        using var db = new FreshDatabase();
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('', 1, 1);"));
+    }
+
+    [TestMethod]
+    public void WhitespaceColumnTitleIsAccepted()
+    {
+        using var db = new FreshDatabase();
+        // No trimming: a single space is a non-empty title as far as the DDL is concerned.
+        int affected = SqliteTestHelper.Exec(
+            db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES (' ', 1, 1);");
+        Assert.AreEqual(1, affected);
+    }
+
+    [TestMethod]
+    public void DuplicateColumnTitleIsRejected()
+    {
+        using var db = new FreshDatabase();
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('Foo', 1, 1);");
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('Foo', 1, 1);"));
+    }
+
+    [TestMethod]
+    public void ColumnTitlesCompareCaseSensitively()
+    {
+        using var db = new FreshDatabase();
+        // BINARY collation: 'Foo' and 'foo' are distinct titles.
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('Foo', 1, 1);");
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('foo', 1, 1);");
+        Assert.AreEqual(2L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM columns;"));
+    }
+
+    [TestMethod]
+    public void EmptyTagNameIsRejected()
+    {
+        using var db = new FreshDatabase();
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO tags (name, color) VALUES ('', '#112233');"));
+    }
+
+    [TestMethod]
+    public void TagNamesAcceptSpacesEmojiAndReservedWords()
+    {
+        using var db = new FreshDatabase();
+        // Tag names are fully open: no charset or length rules, no trimming.
+        foreach (string name in new[] { " ", "a b", "🏷️", "AND", "tag:with:colons" })
+        {
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO tags (name, color) VALUES ($n, '#112233');", ("$n", name));
+        }
+        Assert.AreEqual(5L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM tags;"));
+    }
+
+    [TestMethod]
+    public void DuplicateTagNameIsRejected()
+    {
+        using var db = new FreshDatabase();
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO tags (name, color) VALUES ('bug', '#112233');");
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO tags (name, color) VALUES ('bug', '#445566');"));
+    }
+
+    [TestMethod]
+    [DataRow("#000000")]
+    [DataRow("#FFFFFF")]
+    [DataRow("#a1B2c3")]
+    public void ValidTagColorsAreAccepted(string color)
+    {
+        using var db = new FreshDatabase();
+        int affected = SqliteTestHelper.Exec(
+            db.Connection, "INSERT INTO tags (name, color) VALUES ('x', $c);", ("$c", color));
+        Assert.AreEqual(1, affected);
+    }
+
+    [TestMethod]
+    [DataRow("112233")]
+    [DataRow("#11223")]
+    [DataRow("#1122334")]
+    [DataRow("#G1B2C3")]
+    [DataRow("#a1b2g3")]
+    [DataRow(" #112233")]
+    [DataRow("#112233 ")]
+    [DataRow("")]
+    public void InvalidTagColorsAreRejected(string color)
+    {
+        using var db = new FreshDatabase();
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO tags (name, color) VALUES ('x', $c);", ("$c", color)));
+    }
+
+    [TestMethod]
+    public void CardRequiresExistingColumn()
+    {
+        using var db = new FreshDatabase();
+        // foreign_keys=ON makes the FK enforceable; this is the DDL contract behind the cascades.
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO cards (column_id, created_at, updated_at) VALUES (999, 1, 1);"));
+    }
+
+    [TestMethod]
+    public void CardDefaultsToEmptyTitleAndContent()
+    {
+        using var db = new FreshDatabase();
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('c', 1, 1);");
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO cards (column_id, created_at, updated_at) VALUES (1, 1, 1);");
+
+        // No title is represented by the empty string.
+        Assert.AreEqual(string.Empty, SqliteTestHelper.ScalarString(db.Connection, "SELECT title FROM cards WHERE id = 1;"));
+        Assert.AreEqual(string.Empty, SqliteTestHelper.ScalarString(db.Connection, "SELECT content FROM cards WHERE id = 1;"));
+    }
+
+    [TestMethod]
+    public void CardTagDuplicateAssignmentIsRejected()
+    {
+        using var db = new FreshDatabase();
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('c', 1, 1);");
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO cards (column_id, created_at, updated_at) VALUES (1, 1, 1);");
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO tags (name, color) VALUES ('bug', '#112233');");
+        SqliteTestHelper.Exec(db.Connection, "INSERT INTO card_tags (card_id, tag_id) VALUES (1, 1);");
+
+        // Composite primary key: the same (card, tag) pair cannot be inserted twice.
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(db.Connection, "INSERT INTO card_tags (card_id, tag_id) VALUES (1, 1);"));
+    }
+
+    [TestMethod]
+    public void DeletingColumnCascadesToCardsAndCardTags()
+    {
+        using var db = new FreshDatabase();
+        InsertBoardRow(db.Connection);
+
+        SqliteTestHelper.Exec(db.Connection, "DELETE FROM columns WHERE id = 1;");
+
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM columns;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM cards;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM card_tags;"));
+        // Tags are never cleaned up automatically.
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM tags;"));
+    }
+
+    [TestMethod]
+    public void DeletingCardCascadesToCardTagsOnly()
+    {
+        using var db = new FreshDatabase();
+        InsertBoardRow(db.Connection);
+
+        SqliteTestHelper.Exec(db.Connection, "DELETE FROM cards WHERE id = 1;");
+
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM columns;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM cards;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM card_tags;"));
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM tags;"));
+    }
+
+    [TestMethod]
+    public void DeletingTagRemovesAssignmentsButKeepsCards()
+    {
+        using var db = new FreshDatabase();
+        InsertBoardRow(db.Connection);
+
+        SqliteTestHelper.Exec(db.Connection, "DELETE FROM tags WHERE id = 1;");
+
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM tags;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM card_tags;"));
+        // The card merely loses the tag.
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM cards;"));
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(db.Connection, "SELECT COUNT(*) FROM columns;"));
+    }
+
+    /// <summary>
+    /// Inserts one column, one card, one tag and their assignment, ready for a cascade test.
+    /// </summary>
+    /// <param name="connection">An open workspace-schema connection.</param>
+    private static void InsertBoardRow(SqliteConnection connection)
+    {
+        SqliteTestHelper.Exec(connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('c', 1, 1);");
+        SqliteTestHelper.Exec(connection, "INSERT INTO cards (column_id, created_at, updated_at) VALUES (1, 1, 1);");
+        SqliteTestHelper.Exec(connection, "INSERT INTO tags (name, color) VALUES ('bug', '#112233');");
+        SqliteTestHelper.Exec(connection, "INSERT INTO card_tags (card_id, tag_id) VALUES (1, 1);");
+    }
+}