feat: add storage foundation and i18n resources

YKanBan.Tests/Launching/LaunchArgumentsTests.cs

@@ -0,0 +1,40 @@
+using YKanBan.Launching;
+
+namespace YKanBan.Tests.Launching;
+
+/// <summary>
+/// Tests for the <c>ykanban &lt;path&gt;</c> command-line contract across its
+/// three branches: no argument, one valid path, and invalid input.
+/// </summary>
+[TestClass]
+public class LaunchArgumentsTests
+{
+    [TestMethod]
+    public void NoArgumentsIsRejected()
+    {
+        Assert.IsFalse(LaunchArguments.TryParse([], out string? path));
+        Assert.IsNull(path);
+    }
+
+    [TestMethod]
+    public void BlankArgumentIsRejected()
+    {
+        Assert.IsFalse(LaunchArguments.TryParse(["   "], out string? path));
+        Assert.IsNull(path);
+    }
+
+    [TestMethod]
+    public void MoreThanOneArgumentIsRejected()
+    {
+        Assert.IsFalse(LaunchArguments.TryParse(["a", "b"], out string? path));
+        Assert.IsNull(path);
+    }
+
+    [TestMethod]
+    public void SinglePathIsAccepted()
+    {
+        bool parsed = LaunchArguments.TryParse([@"C:\Repo\MyProject"], out string? path);
+        Assert.IsTrue(parsed);
+        Assert.AreEqual(@"C:\Repo\MyProject", path);
+    }
+}

YKanBan.Tests/Storage/AppData/AppConfigStoreTests.cs

@@ -0,0 +1,161 @@
+using YKanBan.Storage.AppData;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.AppData;
+
+/// <summary>
+/// Tests for app.json round-tripping, kebab-case naming and graceful
+/// degradation on a missing or corrupt file.
+/// </summary>
+[TestClass]
+public class AppConfigStoreTests
+{
+    [TestMethod]
+    public void LoadMissingFileReturnsDefaults()
+    {
+        using var directory = new TempDirectory();
+        var store = new AppConfigStore(Path.Combine(directory.FullPath, "app.json"));
+
+        AppConfig config = store.Load();
+
+        Assert.AreEqual(AppConfig.CurrentFormatVersion, config.Version);
+        Assert.AreEqual(AppConfig.DefaultLanguage, config.Language);
+        Assert.AreEqual(ThemeOption.FollowSystem, config.Theme);
+        Assert.AreEqual(CardSortOption.Id, config.Sort.Card);
+        Assert.AreEqual(ColumnWidthPreset.Standard, config.ColumnWidth.Preset);
+        Assert.AreEqual(320, config.ColumnWidth.CustomPixels);
+        Assert.IsTrue(config.Confirmations.DeleteCard);
+        Assert.IsTrue(config.Confirmations.DeleteColumn);
+        Assert.IsTrue(config.Confirmations.DeleteTag);
+        Assert.IsTrue(config.Confirmations.DiscardEdit);
+    }
+
+    [TestMethod]
+    public void LoadCorruptFileBacksUpAndReturnsDefaults()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, "{ this is not valid json");
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        Assert.AreEqual(AppConfig.CurrentFormatVersion, config.Version);
+        Assert.IsTrue(File.Exists(path + ".bak"));
+        Assert.AreEqual("{ this is not valid json", File.ReadAllText(path + ".bak"));
+    }
+
+    [TestMethod]
+    public void LoadJsonNullReturnsDefaults()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, "null");
+        var store = new AppConfigStore(path);
+
+        Assert.AreEqual(AppConfig.CurrentFormatVersion, store.Load().Version);
+    }
+
+    [TestMethod]
+    public void LoadReadsKebabCaseKeysAndEnumValues()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, $$"""
+            {
+              "version": {{AppConfig.CurrentFormatVersion}},
+              "language": "zh-Hans",
+              "theme": "dark",
+              "sort": { "card": "title" },
+              "column-width": { "preset": "custom", "custom-pixels": 400 },
+              "confirmations": {
+                "delete-card": false,
+                "delete-column": false,
+                "delete-tag": false,
+                "discard-edit": false
+              }
+            }
+            """);
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        Assert.AreEqual("zh-Hans", config.Language);
+        Assert.AreEqual(ThemeOption.Dark, config.Theme);
+        Assert.AreEqual(CardSortOption.Title, config.Sort.Card);
+        Assert.AreEqual(ColumnWidthPreset.Custom, config.ColumnWidth.Preset);
+        Assert.AreEqual(400, config.ColumnWidth.CustomPixels);
+        Assert.IsFalse(config.Confirmations.DeleteCard);
+        Assert.IsFalse(config.Confirmations.DeleteColumn);
+        Assert.IsFalse(config.Confirmations.DeleteTag);
+        Assert.IsFalse(config.Confirmations.DiscardEdit);
+    }
+
+    [TestMethod]
+    public void LoadMissingSectionsFillsDefaults()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, $$"""{ "version": {{AppConfig.CurrentFormatVersion}} }""");
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        Assert.IsNotNull(config.Sort);
+        Assert.IsNotNull(config.ColumnWidth);
+        Assert.IsNotNull(config.Confirmations);
+        Assert.AreEqual(ColumnWidthPreset.Standard, config.ColumnWidth.Preset);
+    }
+
+    [TestMethod]
+    public void SaveWritesKebabCaseKeysAndEnumValues()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        var store = new AppConfigStore(path);
+
+        var config = new AppConfig
+        {
+            Theme = ThemeOption.FollowSystem,
+            Sort = new SortSettings { Card = CardSortOption.UpdatedAt },
+            ColumnWidth = new ColumnWidthSettings { Preset = ColumnWidthPreset.Custom, CustomPixels = 500 },
+            Confirmations = new ConfirmationSettings { DeleteColumn = false },
+        };
+        store.Save(config);
+
+        string json = File.ReadAllText(path);
+        StringAssert.Contains(json, "\"delete-column\"");
+        StringAssert.Contains(json, "\"discard-edit\"");
+        StringAssert.Contains(json, "\"custom-pixels\"");
+        StringAssert.Contains(json, "\"follow-system\"");
+        StringAssert.Contains(json, "\"updated-at\"");
+        // No member-name CamelCase must leak into the file.
+        Assert.IsFalse(json.Contains("deleteColumn", StringComparison.Ordinal));
+        Assert.IsFalse(json.Contains("CustomPixels", StringComparison.Ordinal));
+    }
+
+    [TestMethod]
+    public void SaveThenLoadRoundTrips()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        var store = new AppConfigStore(path);
+
+        var config = new AppConfig
+        {
+            Language = "zh-Hans",
+            Theme = ThemeOption.Light,
+            Sort = new SortSettings { Card = CardSortOption.CreatedAt },
+            ColumnWidth = new ColumnWidthSettings { Preset = ColumnWidthPreset.Wide },
+            Confirmations = new ConfirmationSettings { DiscardEdit = false },
+        };
+        store.Save(config);
+
+        AppConfig reloaded = store.Load();
+        Assert.AreEqual(config.Language, reloaded.Language);
+        Assert.AreEqual(config.Theme, reloaded.Theme);
+        Assert.AreEqual(config.Sort.Card, reloaded.Sort.Card);
+        Assert.AreEqual(config.ColumnWidth.Preset, reloaded.ColumnWidth.Preset);
+        Assert.AreEqual(config.Confirmations.DiscardEdit, reloaded.Confirmations.DiscardEdit);
+    }
+}

YKanBan.Tests/Storage/SqliteDatabaseTests.cs

@@ -0,0 +1,83 @@
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage;
+
+/// <summary>
+/// Tests for the shared SQLite plumbing: mandatory PRAGMAs and the
+/// user_version-driven migration runner.
+/// </summary>
+[TestClass]
+public class SqliteDatabaseTests
+{
+    [TestMethod]
+    public void OpenAppliesMandatoryPragmas()
+    {
+        using var directory = new TempDirectory();
+        string databasePath = Path.Combine(directory.FullPath, "pragmas.db");
+
+        using SqliteConnection connection = SqliteDatabase.Open(databasePath, []);
+        Assert.AreEqual("wal", SqliteTestHelper.ScalarString(connection, "PRAGMA journal_mode;"));
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(connection, "PRAGMA synchronous;"));
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(connection, "PRAGMA foreign_keys;"));
+    }
+
+    [TestMethod]
+    public void OpenSetsUserVersionToLatestMigration()
+    {
+        using var directory = new TempDirectory();
+        string databasePath = Path.Combine(directory.FullPath, "version.db");
+
+        using SqliteConnection connection = SqliteDatabase.Open(databasePath, WorkspaceSchema.Migrations);
+        Assert.AreEqual(WorkspaceSchema.CurrentVersion, SqliteDatabase.ReadUserVersion(connection));
+    }
+
+    [TestMethod]
+    public void ReopenKeepsWalJournalMode()
+    {
+        using var directory = new TempDirectory();
+        string databasePath = Path.Combine(directory.FullPath, "wal.db");
+
+        using (SqliteConnection connection = SqliteDatabase.Open(databasePath, WorkspaceSchema.Migrations))
+        {
+        }
+
+        // WAL mode is stored in the database header, so a fresh connection keeps it.
+        using SqliteConnection reopened = SqliteDatabase.Open(databasePath, WorkspaceSchema.Migrations);
+        Assert.AreEqual("wal", SqliteTestHelper.ScalarString(reopened, "PRAGMA journal_mode;"));
+    }
+
+    [TestMethod]
+    public void OpenRejectsNewerStoredSchemaVersion()
+    {
+        using var directory = new TempDirectory();
+        string databasePath = Path.Combine(directory.FullPath, "newer.db");
+
+        long newerVersion = WorkspaceSchema.CurrentVersion + 1;
+        using (SqliteConnection connection = SqliteDatabase.Open(databasePath, WorkspaceSchema.Migrations))
+        {
+            SqliteTestHelper.Exec(connection, $"PRAGMA user_version={newerVersion};");
+        }
+
+        SchemaVersionException exception = Assert.ThrowsExactly<SchemaVersionException>(
+            () => SqliteDatabase.Open(databasePath, WorkspaceSchema.Migrations));
+        Assert.AreEqual(newerVersion, exception.StoredVersion);
+        Assert.AreEqual(WorkspaceSchema.CurrentVersion, exception.SupportedVersion);
+    }
+
+    [TestMethod]
+    public void OpenRejectsNonContiguousMigrationList()
+    {
+        using var directory = new TempDirectory();
+        string databasePath = Path.Combine(directory.FullPath, "gap.db");
+
+        SchemaMigration[] broken =
+        [
+            new SchemaMigration(2, "starts too high", "SELECT 1;"),
+        ];
+
+        Assert.ThrowsExactly<ArgumentException>(() => SqliteDatabase.Open(databasePath, broken));
+    }
+}

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

YKanBan.Tests/TestUtilities/SqliteTestHelper.cs

@@ -0,0 +1,99 @@
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+
+namespace YKanBan.Tests.TestUtilities;
+
+/// <summary>
+/// Shared helpers for the storage tests: small SQL conveniences plus opening a
+/// workspace database with the real migration list.
+/// </summary>
+public static class SqliteTestHelper
+{
+    /// <summary>
+    /// Executes a non-query SQL statement and returns the affected row count.
+    /// </summary>
+    /// <param name="connection">An open database connection.</param>
+    /// <param name="sql">The statement to execute.</param>
+    /// <param name="parameters">Name/value pairs bound as SQL parameters.</param>
+    /// <returns>The number of affected rows.</returns>
+    public static int Exec(SqliteConnection connection, string sql, params (string Name, object? Value)[] parameters)
+    {
+        using var command = connection.CreateCommand();
+        command.CommandText = sql;
+        foreach ((string name, object? value) in parameters)
+        {
+            command.Parameters.AddWithValue(name, value);
+        }
+        return command.ExecuteNonQuery();
+    }
+
+    /// <summary>
+    /// Returns the scalar result of a SQL query as a string.
+    /// </summary>
+    /// <param name="connection">An open database connection.</param>
+    /// <param name="sql">The query to execute.</param>
+    /// <returns>The scalar result cast to a string.</returns>
+    public static string ScalarString(SqliteConnection connection, string sql)
+    {
+        using var command = connection.CreateCommand();
+        command.CommandText = sql;
+        return (string)command.ExecuteScalar()!;
+    }
+
+    /// <summary>
+    /// Returns the scalar result of a SQL query as a long.
+    /// </summary>
+    /// <param name="connection">An open database connection.</param>
+    /// <param name="sql">The query to execute.</param>
+    /// <returns>The scalar result cast to a long.</returns>
+    public static long ScalarLong(SqliteConnection connection, string sql)
+    {
+        using var command = connection.CreateCommand();
+        command.CommandText = sql;
+        return (long)command.ExecuteScalar()!;
+    }
+
+    /// <summary>
+    /// Returns whether a table with the given name exists in the database.
+    /// </summary>
+    /// <param name="connection">An open database connection.</param>
+    /// <param name="tableName">The table name to look for.</param>
+    /// <returns><see langword="true"/> when the table exists.</returns>
+    public static bool TableExists(SqliteConnection connection, string tableName)
+    {
+        using var command = connection.CreateCommand();
+        command.CommandText = "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=$name;";
+        command.Parameters.AddWithValue("$name", tableName);
+        return (long)command.ExecuteScalar()! == 1;
+    }
+
+    /// <summary>
+    /// Returns the titles of all columns, ordered by id ascending.
+    /// </summary>
+    /// <param name="connection">An open database connection.</param>
+    /// <returns>The column titles in id order.</returns>
+    public static List<string> GetColumnTitles(SqliteConnection connection)
+    {
+        using var command = connection.CreateCommand();
+        command.CommandText = "SELECT title FROM columns ORDER BY id ASC;";
+        using var reader = command.ExecuteReader();
+
+        var titles = new List<string>();
+        while (reader.Read())
+        {
+            titles.Add(reader.GetString(0));
+        }
+        return titles;
+    }
+
+    /// <summary>
+    /// Opens a workspace database with the real workspace migration list.
+    /// </summary>
+    /// <param name="folderPath">The workspace folder path.</param>
+    /// <returns>An open, migrated connection.</returns>
+    public static SqliteConnection OpenWorkspace(string folderPath)
+    {
+        return SqliteDatabase.Open(WorkspacePaths.Database(folderPath), WorkspaceSchema.Migrations);
+    }
+}

YKanBan.Tests/TestUtilities/TempDirectory.cs

@@ -0,0 +1,43 @@
+namespace YKanBan.Tests.TestUtilities;
+
+/// <summary>
+/// Creates a unique temporary directory per test instance and removes it on
+/// disposal. The removal is retried once because SQLite WAL sidecar files can
+/// linger for a moment after the connections close.
+/// </summary>
+public sealed class TempDirectory : IDisposable
+{
+    /// <summary>
+    /// Gets the unique directory path managed by this instance.
+    /// </summary>
+    public string FullPath { get; }
+
+    public TempDirectory()
+    {
+        FullPath = Path.Combine(Path.GetTempPath(), "ykanban-tests-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(FullPath);
+    }
+
+    /// <summary>
+    /// Deletes the directory tree, retrying once after a short delay.
+    /// </summary>
+    public void Dispose()
+    {
+        try
+        {
+            Directory.Delete(FullPath, recursive: true);
+        }
+        catch (IOException)
+        {
+            Thread.Sleep(100);
+            try
+            {
+                Directory.Delete(FullPath, recursive: true);
+            }
+            catch (IOException)
+            {
+                // Leftovers in the OS temp folder are harmless; never fail a test over cleanup.
+            }
+        }
+    }
+}

YKanBan.Tests/YKanBan.Tests.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>