feat(m1): storage layer

- Shared SQLite plumbing: PRAGMAs (WAL/NORMAL/foreign_keys) and user_version migrations with typed SchemaVersionException - Workspace folder: .ykanban initialization, empty schema with DDL-level constraints, preset column seeding (ResX-driven), exclusive lock file with holder diagnostics - AppData folder: app.db workspace registry (injectable clock), app.json config store with kebab-case JSON names via explicit [JsonProperty]/[EnumMember], nested sections, corrupt-file backup - ResX infrastructure under Assets/Locales (en + zh-Hans) with MSBuild strongly-typed public Resources class - 54 unit tests: DDL constraints, migrations, PRAGMAs, lock exclusivity, config degradation, culture-aware presets
2026-10-01 18:17:47 +08:00
1 parent e934eb9629
commit 31fc58d9c7
@@ -0,0 +1,169 @@
+using YKanBan.Storage.AppData;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.AppData;
+
+/// <summary>Tests for app.json load/save and its degradation rules.</summary>
+[TestClass]
+public class AppConfigStoreTests
+{
+    [TestMethod]
+    public void MissingFileYieldsDefaults()
+    {
+        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("en", config.Language);
+        Assert.AreEqual(ThemeOption.FollowSystem, config.Theme);
+        Assert.AreEqual(CardSortOption.Id, config.Sort.Card);
+        Assert.AreEqual(SidebarSortOption.NameAsc, config.Sort.Sidebar);
+        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 CorruptJsonIsBackedUpAndDefaultsAreUsed()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, "{{{ not json");
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        Assert.AreEqual("en", config.Language);
+        Assert.IsTrue(File.Exists(path + ".bak"));
+        Assert.AreEqual("{{{ not json", File.ReadAllText(path + ".bak"));
+    }
+
+    [TestMethod]
+    public void WrongShapeJsonIsBackedUpAndDefaultsAreUsed()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, "[1, 2, 3]");
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        Assert.AreEqual(AppConfig.CurrentFormatVersion, config.Version);
+        Assert.IsTrue(File.Exists(path + ".bak"));
+    }
+
+    [TestMethod]
+    public void SaveAndLoadRoundTripsAllSettings()
+    {
+        using var directory = new TempDirectory();
+        var store = new AppConfigStore(Path.Combine(directory.FullPath, "app.json"));
+
+        store.Save(new AppConfig
+        {
+            Language = "zh-Hans",
+            Theme = ThemeOption.Dark,
+            Sort = new SortSettings
+            {
+                Card = CardSortOption.Title,
+                Sidebar = SidebarSortOption.RecentlyUpdated,
+            },
+            ColumnWidth = new ColumnWidthSettings
+            {
+                Preset = ColumnWidthPreset.Custom,
+                CustomPixels = 500,
+            },
+            Confirmations = new ConfirmationSettings
+            {
+                DeleteCard = false,
+                DeleteColumn = false,
+                DeleteTag = false,
+                DiscardEdit = false,
+            },
+        });
+        AppConfig loaded = store.Load();
+
+        Assert.AreEqual("zh-Hans", loaded.Language);
+        Assert.AreEqual(ThemeOption.Dark, loaded.Theme);
+        Assert.AreEqual(CardSortOption.Title, loaded.Sort.Card);
+        Assert.AreEqual(SidebarSortOption.RecentlyUpdated, loaded.Sort.Sidebar);
+        Assert.AreEqual(ColumnWidthPreset.Custom, loaded.ColumnWidth.Preset);
+        Assert.AreEqual(500, loaded.ColumnWidth.CustomPixels);
+        Assert.IsFalse(loaded.Confirmations.DeleteCard);
+        Assert.IsFalse(loaded.Confirmations.DeleteColumn);
+        Assert.IsFalse(loaded.Confirmations.DeleteTag);
+        Assert.IsFalse(loaded.Confirmations.DiscardEdit);
+    }
+
+    [TestMethod]
+    public void SaveWritesKebabCaseNamesAndVersionField()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        var store = new AppConfigStore(path);
+
+        store.Save(new AppConfig());
+        string json = File.ReadAllText(path);
+
+        // Keys and enum values are serialized in kebab-case; "version" is the migration hook.
+        Assert.IsTrue(json.Contains($"\"version\": {AppConfig.CurrentFormatVersion}"));
+        Assert.IsTrue(json.Contains("\"language\": \"en\""));
+        Assert.IsTrue(json.Contains("\"theme\": \"follow-system\""));
+        Assert.IsTrue(json.Contains("\"sort\":"));
+        Assert.IsTrue(json.Contains("\"card\": \"id\""));
+        Assert.IsTrue(json.Contains("\"sidebar\": \"name-asc\""));
+        Assert.IsTrue(json.Contains("\"column-width\":"));
+        Assert.IsTrue(json.Contains("\"preset\": \"standard\""));
+        Assert.IsTrue(json.Contains("\"custom-pixels\": 320"));
+        Assert.IsTrue(json.Contains("\"confirmations\":"));
+        Assert.IsTrue(json.Contains("\"delete-card\": true"));
+        Assert.IsTrue(json.Contains("\"delete-column\": true"));
+        Assert.IsTrue(json.Contains("\"delete-tag\": true"));
+        Assert.IsTrue(json.Contains("\"discard-edit\": true"));
+    }
+
+    [TestMethod]
+    public void MissingSectionsFallBackToTheirDefaults()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        File.WriteAllText(path, $$"""
+            {
+              "version": {{AppConfig.CurrentFormatVersion}},
+              "language": "zh-Hans"
+            }
+            """);
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        // The present field loads; absent sections each fall back to defaults.
+        Assert.AreEqual("zh-Hans", config.Language);
+        Assert.AreEqual(CardSortOption.Id, config.Sort.Card);
+        Assert.AreEqual(ColumnWidthPreset.Standard, config.ColumnWidth.Preset);
+        Assert.IsTrue(config.Confirmations.DeleteCard);
+    }
+
+    [TestMethod]
+    public void LoadPreservesUnknownFieldsTolerantly()
+    {
+        using var directory = new TempDirectory();
+        string path = Path.Combine(directory.FullPath, "app.json");
+        // A newer version writes an unknown field plus a known one.
+        File.WriteAllText(path, $$"""
+            {
+              "version": {{AppConfig.CurrentFormatVersion}},
+              "language": "zh-Hans",
+              "some-future-field": 42
+            }
+            """);
+        var store = new AppConfigStore(path);
+
+        AppConfig config = store.Load();
+
+        Assert.AreEqual("zh-Hans", config.Language);
+    }
+}
@@ -0,0 +1,136 @@
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage;
+using YKanBan.Storage.AppData;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.AppData;
+
+/// <summary>Tests for the global app.db workspace registry.</summary>
+[TestClass]
+public class AppDatabaseTests
+{
+    private static string DatabasePath(TempDirectory directory)
+        => Path.Combine(directory.FullPath, "app.db");
+
+    [TestMethod]
+    public void UpsertInsertsRowWithTimestamps()
+    {
+        using var directory = new TempDirectory();
+        long now = 1000;
+        using var db = new AppDatabase(DatabasePath(directory), () => now);
+
+        db.UpsertWorkspace(@"C:\work\repo");
+
+        IReadOnlyList<WorkspaceRecord> records = db.GetWorkspaces();
+        Assert.AreEqual(1, records.Count);
+        Assert.AreEqual(@"C:\work\repo", records[0].Path);
+        Assert.AreEqual(1000L, records[0].AddedAt);
+        Assert.AreEqual(1000L, records[0].LastEditedAt);
+    }
+
+    [TestMethod]
+    public void RepeatedUpsertKeepsOriginalAddedAt()
+    {
+        using var directory = new TempDirectory();
+        long now = 1000;
+        using var db = new AppDatabase(DatabasePath(directory), () => now);
+
+        db.UpsertWorkspace(@"C:\work\repo");
+        now = 2000;
+        db.UpsertWorkspace(@"C:\work\repo");
+
+        WorkspaceRecord record = db.GetWorkspaces().Single();
+        Assert.AreEqual(1000L, record.AddedAt);
+        Assert.AreEqual(2000L, record.LastEditedAt);
+    }
+
+    [TestMethod]
+    public void TouchRefreshesLastEditedAt()
+    {
+        using var directory = new TempDirectory();
+        long now = 1000;
+        using var db = new AppDatabase(DatabasePath(directory), () => now);
+
+        db.UpsertWorkspace(@"C:\work\repo");
+        now = 2500;
+        db.TouchLastEdited(@"C:\work\repo");
+
+        WorkspaceRecord record = db.GetWorkspaces().Single();
+        Assert.AreEqual(1000L, record.AddedAt);
+        Assert.AreEqual(2500L, record.LastEditedAt);
+    }
+
+    [TestMethod]
+    public void TouchOnUnknownPathRegistersTheWorkspace()
+    {
+        using var directory = new TempDirectory();
+        long now = 3000;
+        using var db = new AppDatabase(DatabasePath(directory), () => now);
+
+        // Self-healing: touching an unregistered workspace still leaves a valid row.
+        db.TouchLastEdited(@"C:\work\other");
+
+        WorkspaceRecord record = db.GetWorkspaces().Single();
+        Assert.AreEqual(3000L, record.AddedAt);
+        Assert.AreEqual(3000L, record.LastEditedAt);
+    }
+
+    [TestMethod]
+    public void RemoveDeletesTheRow()
+    {
+        using var directory = new TempDirectory();
+        using var db = new AppDatabase(DatabasePath(directory));
+
+        db.UpsertWorkspace(@"C:\work\repo");
+        db.RemoveWorkspace(@"C:\work\repo");
+
+        Assert.AreEqual(0, db.GetWorkspaces().Count);
+    }
+
+    [TestMethod]
+    public void RowsPersistAcrossReopen()
+    {
+        using var directory = new TempDirectory();
+        string path = DatabasePath(directory);
+
+        using (var db = new AppDatabase(path, () => 1000))
+        {
+            db.UpsertWorkspace(@"C:\work\repo");
+        }
+
+        using var reopened = new AppDatabase(path, () => 9999);
+        WorkspaceRecord record = reopened.GetWorkspaces().Single();
+        Assert.AreEqual(@"C:\work\repo", record.Path);
+        Assert.AreEqual(1000L, record.AddedAt);
+    }
+
+    [TestMethod]
+    public void OpenMigratesToCurrentSchemaVersion()
+    {
+        using var directory = new TempDirectory();
+        string path = DatabasePath(directory);
+        using (var db = new AppDatabase(path))
+        {
+        }
+
+        using var raw = new SqliteConnection($"Data Source={path}");
+        raw.Open();
+        Assert.AreEqual(AppDatabase.CurrentSchemaVersion, SqliteDatabase.ReadUserVersion(raw));
+    }
+
+    [TestMethod]
+    public void OpenAppliesWalJournalMode()
+    {
+        using var directory = new TempDirectory();
+        string path = DatabasePath(directory);
+        using (var db = new AppDatabase(path))
+        {
+        }
+
+        // WAL is a persistent property of the database file: a plain new
+        // connection reports it without any PRAGMA replay.
+        using var raw = new SqliteConnection($"Data Source={path}");
+        raw.Open();
+        Assert.AreEqual("wal", SqliteTestHelper.ScalarString(raw, "PRAGMA journal_mode;"));
+    }
+}
@@ -0,0 +1,114 @@
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage;
+
+/// <summary>Tests for PRAGMA application and user_version migration machinery.</summary>
+[TestClass]
+public class SqliteDatabaseTests
+{
+    private static readonly SchemaMigration[] V1Only =
+    [
+        new SchemaMigration(1, "v1", "CREATE TABLE t1 (id INTEGER PRIMARY KEY);"),
+    ];
+
+    private static readonly SchemaMigration[] V1AndV2 =
+    [
+        new SchemaMigration(1, "v1", "CREATE TABLE t1 (id INTEGER PRIMARY KEY);"),
+        new SchemaMigration(2, "v2", "CREATE TABLE t2 (id INTEGER PRIMARY KEY);"),
+    ];
+
+    [TestMethod]
+    public void OpenAppliesMandatedPragmas()
+    {
+        using var directory = new TempDirectory();
+        string dbPath = Path.Combine(directory.FullPath, "test.db");
+
+        using var connection = SqliteDatabase.Open(dbPath, []);
+        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 OpenSetsUserVersionToLatestWorkspaceMigration()
+    {
+        using var directory = new TempDirectory();
+        string dbPath = Path.Combine(directory.FullPath, "test.db");
+
+        using var connection = SqliteDatabase.Open(dbPath, WorkspaceSchema.Migrations);
+        Assert.AreEqual(WorkspaceSchema.CurrentVersion, SqliteDatabase.ReadUserVersion(connection));
+    }
+
+    [TestMethod]
+    public void MigrationsApplyIncrementallyOnReopen()
+    {
+        using var directory = new TempDirectory();
+        string dbPath = Path.Combine(directory.FullPath, "test.db");
+
+        // First open with only v1 available: v1 applied, v2 table absent.
+        using (var connection = SqliteDatabase.Open(dbPath, V1Only))
+        {
+            Assert.AreEqual(1L, SqliteDatabase.ReadUserVersion(connection));
+            Assert.IsTrue(SqliteTestHelper.TableExists(connection, "t1"));
+            Assert.IsFalse(SqliteTestHelper.TableExists(connection, "t2"));
+        }
+
+        // Reopen with v1+v2: only v2 runs, v1 data untouched.
+        using (var connection = SqliteDatabase.Open(dbPath, V1AndV2))
+        {
+            Assert.AreEqual(2L, SqliteDatabase.ReadUserVersion(connection));
+            Assert.IsTrue(SqliteTestHelper.TableExists(connection, "t1"));
+            Assert.IsTrue(SqliteTestHelper.TableExists(connection, "t2"));
+        }
+    }
+
+    [TestMethod]
+    public void ReopenWithCurrentSchemaIsIdempotent()
+    {
+        using var directory = new TempDirectory();
+        string dbPath = Path.Combine(directory.FullPath, "test.db");
+
+        SqliteDatabase.Open(dbPath, V1AndV2).Dispose();
+        using (var connection = SqliteDatabase.Open(dbPath, V1AndV2))
+        {
+            // Still at version 2; re-running is a no-op.
+            Assert.AreEqual(2L, SqliteDatabase.ReadUserVersion(connection));
+            SqliteTestHelper.Exec(connection, "INSERT INTO t1 (id) VALUES (42);");
+        }
+
+        using (var connection = SqliteDatabase.Open(dbPath, V1AndV2))
+        {
+            Assert.AreEqual(42L, SqliteTestHelper.ScalarLong(connection, "SELECT id FROM t1;"));
+        }
+    }
+
+    [TestMethod]
+    public void NewerSchemaVersionIsRejected()
+    {
+        using var directory = new TempDirectory();
+        string dbPath = Path.Combine(directory.FullPath, "test.db");
+
+        // Simulate a database written by a newer build.
+        using (var connection = SqliteDatabase.Open(dbPath, []))
+        {
+            SqliteTestHelper.Exec(connection, "PRAGMA user_version=5;");
+        }
+
+        SchemaVersionException ex = Assert.ThrowsExactly<SchemaVersionException>(
+            () => SqliteDatabase.Open(dbPath, V1AndV2));
+        Assert.AreEqual(5L, ex.StoredVersion);
+        Assert.AreEqual(2, ex.SupportedVersion);
+    }
+
+    [TestMethod]
+    public void NonContiguousMigrationListIsRejected()
+    {
+        using var directory = new TempDirectory();
+        string dbPath = Path.Combine(directory.FullPath, "test.db");
+        var bad = new[] { new SchemaMigration(2, "gap", "CREATE TABLE t (id INTEGER);") };
+
+        Assert.ThrowsExactly<ArgumentException>(() => SqliteDatabase.Open(dbPath, bad));
+    }
+}
@@ -0,0 +1,59 @@
+using System.Globalization;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>
+/// Verifies that preset column titles follow the UI language active at
+/// seeding time and then live as ordinary data. Mutates the global
+/// Resources.Culture, therefore marked DoNotParallelize.
+/// </summary>
+[TestClass]
+[DoNotParallelize]
+public class PresetColumnCultureTests
+{
+    [TestMethod]
+    public void PresetTitlesAreEnglishUnderEnglishCulture()
+    {
+        CultureInfo? original = Resources.Culture;
+        try
+        {
+            Resources.Culture = new CultureInfo("en");
+            using var directory = new TempDirectory();
+            WorkspaceInitializer.Initialize(directory.FullPath);
+            WorkspacePreset.SeedColumns(directory.FullPath);
+
+            using var connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+            CollectionAssert.AreEqual(
+                new[] { "To Do", "In Progress", "Done" },
+                SqliteTestHelper.GetColumnTitles(connection));
+        }
+        finally
+        {
+            Resources.Culture = original;
+        }
+    }
+
+    [TestMethod]
+    public void PresetTitlesAreChineseUnderChineseCulture()
+    {
+        CultureInfo? original = Resources.Culture;
+        try
+        {
+            Resources.Culture = new CultureInfo("zh-Hans");
+            using var directory = new TempDirectory();
+            WorkspaceInitializer.Initialize(directory.FullPath);
+            WorkspacePreset.SeedColumns(directory.FullPath);
+
+            using var connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+            CollectionAssert.AreEqual(
+                new[] { "待办", "进行中", "已完成" },
+                SqliteTestHelper.GetColumnTitles(connection));
+        }
+        finally
+        {
+            Resources.Culture = original;
+        }
+    }
+}
@@ -0,0 +1,53 @@
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>Tests for .ykanban folder and empty database creation.</summary>
+[TestClass]
+public class WorkspaceInitializerTests
+{
+    [TestMethod]
+    public void InitializeCreatesYkanbanFolderAndDatabase()
+    {
+        using var directory = new TempDirectory();
+
+        Assert.IsFalse(WorkspaceInitializer.IsWorkspace(directory.FullPath));
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        Assert.IsTrue(WorkspaceInitializer.IsWorkspace(directory.FullPath));
+        Assert.IsTrue(File.Exists(WorkspacePaths.Database(directory.FullPath)));
+        // The lock file only appears once a WorkspaceLock is acquired.
+        Assert.IsFalse(File.Exists(WorkspacePaths.LockFile(directory.FullPath)));
+    }
+
+    [TestMethod]
+    public void InitializeLeavesDatabaseEmpty()
+    {
+        // Initialization creates structure only; preset content is seeded separately.
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        using var connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM columns;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM cards;"));
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM tags;"));
+    }
+
+    [TestMethod]
+    public void InitializeThrowsWhenDirectoryIsMissing()
+    {
+        string missing = Path.Combine(Path.GetTempPath(), "ykanban-tests-" + Guid.NewGuid().ToString("N"));
+        Assert.ThrowsExactly<WorkspaceDirectoryMissingException>(() => WorkspaceInitializer.Initialize(missing));
+    }
+
+    [TestMethod]
+    public void InitializeThrowsWhenDatabaseAlreadyExists()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+
+        Assert.ThrowsExactly<InvalidOperationException>(() => WorkspaceInitializer.Initialize(directory.FullPath));
+    }
+}
@@ -0,0 +1,57 @@
+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 ex = Assert.ThrowsExactly<WorkspaceLockException>(
+            () => WorkspaceLock.Acquire(directory.FullPath));
+        Assert.AreEqual(WorkspacePaths.LockFile(directory.FullPath), ex.LockFilePath);
+    }
+
+    [TestMethod]
+    public void AcquireWithoutYkanbanThrowsNotInitialized()
+    {
+        using var directory = new TempDirectory();
+        Assert.ThrowsExactly<WorkspaceNotInitializedException>(
+            () => WorkspaceLock.Acquire(directory.FullPath));
+    }
+
+    [TestMethod]
+    public void LockFileContainsHolderDiagnostics()
+    {
+        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}");
+    }
+}
@@ -0,0 +1,39 @@
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>Tests for seeding preset workspace content.</summary>
+[TestClass]
+public class WorkspacePresetTests
+{
+    [TestMethod]
+    public void SeedAddsThreeDistinctPresetColumns()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+        WorkspacePreset.SeedColumns(directory.FullPath);
+
+        using var connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+        List<string> titles = SqliteTestHelper.GetColumnTitles(connection);
+
+        Assert.AreEqual(3, titles.Count);
+        Assert.AreEqual(titles.Count, titles.Distinct().Count());
+        Assert.IsTrue(titles.All(title => title.Length > 0));
+    }
+
+    [TestMethod]
+    public void SeedPresetColumnsShareOneTimestamp()
+    {
+        using var directory = new TempDirectory();
+        WorkspaceInitializer.Initialize(directory.FullPath);
+        WorkspacePreset.SeedColumns(directory.FullPath);
+
+        using var connection = SqliteTestHelper.OpenWorkspace(directory.FullPath);
+
+        // Creation writes created_at = updated_at; all three columns share one moment.
+        Assert.AreEqual(0L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM columns WHERE created_at <> updated_at;"));
+        Assert.AreEqual(3L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM columns WHERE created_at > 0;"));
+        Assert.AreEqual(1L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(DISTINCT created_at) FROM columns;"));
+    }
+}
@@ -0,0 +1,160 @@
+using Microsoft.Data.Sqlite;
+using YKanBan.Storage;
+using YKanBan.Storage.Workspace;
+using YKanBan.Tests.TestUtilities;
+
+namespace YKanBan.Tests.Storage.Workspace;
+
+/// <summary>Verifies that the DDL constraints reject invalid data at the door.</summary>
+[TestClass]
+public class WorkspaceSchemaTests
+{
+    /// <summary>Owns a temp directory plus a fresh workspace-schema database for one 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);
+        }
+
+        public void Dispose()
+        {
+            Connection.Dispose();
+            Directory.Dispose();
+        }
+    }
+
+    [TestMethod]
+    public void EmptyColumnTitleIsRejected()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('', 1, 1);"));
+    }
+
+    [TestMethod]
+    public void DuplicateColumnTitleIsRejected()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        SqliteTestHelper.Exec(connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('Foo', 1, 1);");
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('Foo', 1, 1);"));
+    }
+
+    [TestMethod]
+    public void ColumnTitlesCompareCaseSensitively()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        // BINARY collation: 'Foo' and 'foo' are distinct titles.
+        SqliteTestHelper.Exec(connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('Foo', 1, 1);");
+        SqliteTestHelper.Exec(connection, "INSERT INTO columns (title, created_at, updated_at) VALUES ('foo', 1, 1);");
+        Assert.AreEqual(2L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM columns;"));
+    }
+
+    [TestMethod]
+    public void EmptyTagNameIsRejected()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(connection, "INSERT INTO tags (name, color) VALUES ('', '#112233');"));
+    }
+
+    [TestMethod]
+    public void TagNamesAcceptSpacesEmojiAndReservedWords()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        // 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(connection, "INSERT INTO tags (name, color) VALUES ($n, '#112233');", ("$n", name));
+        }
+        Assert.AreEqual(5L, SqliteTestHelper.ScalarLong(connection, "SELECT COUNT(*) FROM tags;"));
+    }
+
+    [TestMethod]
+    public void DuplicateTagNameIsRejected()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        SqliteTestHelper.Exec(connection, "INSERT INTO tags (name, color) VALUES ('bug', '#112233');");
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(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();
+        using var connection = db.Connection;
+        int affected = SqliteTestHelper.Exec(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();
+        using var connection = db.Connection;
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(connection, "INSERT INTO tags (name, color) VALUES ('x', $c);", ("$c", color)));
+    }
+
+    [TestMethod]
+    public void CardRequiresExistingColumn()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.Connection;
+        // foreign_keys=ON makes the FK enforceable; this is the DDL contract behind the cascades.
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(connection, "INSERT INTO cards (column_id, created_at, updated_at) VALUES (999, 1, 1);"));
+    }
+
+    [TestMethod]
+    public void CardDefaultsToEmptyTitleAndContent()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.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);");
+
+        // No title is represented by the empty string.
+        Assert.AreEqual(string.Empty, SqliteTestHelper.ScalarString(connection, "SELECT title FROM cards WHERE id = 1;"));
+        Assert.AreEqual(string.Empty, SqliteTestHelper.ScalarString(connection, "SELECT content FROM cards WHERE id = 1;"));
+    }
+
+    [TestMethod]
+    public void CardTagDuplicateAssignmentIsRejected()
+    {
+        using var db = new FreshDatabase();
+        using var connection = db.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);");
+
+        // Composite primary key: the same (card, tag) pair cannot be inserted twice.
+        Assert.ThrowsExactly<SqliteException>(() =>
+            SqliteTestHelper.Exec(connection, "INSERT INTO card_tags (card_id, tag_id) VALUES (1, 1);"));
+    }
+}