Seed canonical morph types and regenerate search index

backend/FwLite/FwDataMiniLcmBridge.Tests/MiniLcmTests/SortingTests.cs

@@ -22,9 +22,9 @@ public async Task SecondaryOrder_DefaultsToStem(string query, SortField sortFiel
     {
         var unknownMorphTypeEntryId = Guid.NewGuid();
         Entry[] expected = [
-            new() { Id = unknownMorphTypeEntryId, LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Unknown }, // SecondaryOrder defaults to Stem = 1
-            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.BoundStem }, // SecondaryOrder = 2
-            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Suffix }, // SecondaryOrder = 6
+            new() { Id = unknownMorphTypeEntryId, LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Unknown }, // SecondaryOrder defaults to Stem = 0
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.BoundStem }, // SecondaryOrder = 10
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Suffix }, // SecondaryOrder = 70
         ];
 
         var ids = expected.Select(e => e.Id).ToHashSet();

backend/FwLite/FwLiteProjectSync.Tests/FluentAssertGlobalConfig.cs

@@ -1,3 +1,4 @@
+using System.Runtime.CompilerServices;
 using FluentAssertions.Extensibility;
 using FwLiteProjectSync.Tests;
 
@@ -7,6 +8,12 @@ namespace FwLiteProjectSync.Tests;
 
 public static class FluentAssertGlobalConfig
 {
+    [ModuleInitializer]
+    internal static void InitVerify()
+    {
+        VerifierSettings.OmitContentFromException();
+    }
+
     public static void Initialize()
     {
         MiniLcm.Tests.FluentAssertGlobalConfig.Initialize();

backend/FwLite/FwLiteProjectSync.Tests/Import/ResumableTests.cs

@@ -1,3 +1,4 @@
+using LcmCrdt.Objects;
 using LcmCrdt.Tests;
 using Microsoft.Extensions.Logging.Abstractions;
 using MiniLcm;
@@ -38,18 +39,7 @@ public async Task ImportProject_IsResumable_AcrossRandomFailures()
             }).ToList();
         var expectedPartsOfSpeech = Enumerable.Range(1, 10)
             .Select(i => new PartOfSpeech { Id = Guid.NewGuid(), Name = { ["en"] = $"pos{i}" } }).ToList();
-        var expectedMorphTypes = Enum.GetValues<MorphTypeKind>()
-            .Select(typ => new MorphType()
-            {
-                Id = Guid.NewGuid(),
-                Name = new() { ["en"] = $"Test Morph Type {(int)typ} {typ}" },
-                Abbreviation = new() { ["en"] = $"Tst MrphTyp{(int)typ}" },
-                Description = new() { { "en", new RichString($"test desc for {typ}") } },
-                Prefix = null,
-                Postfix = null,
-                Kind = typ,
-                SecondaryOrder = 0
-            }).ToList();
+        var expectedMorphTypes = CanonicalMorphTypes.All.Values;
 
         var mockFrom = new Mock<IMiniLcmApi>();
         IMiniLcmApi mockTo = new UnreliableApi(
@@ -132,7 +122,6 @@ public async Task ImportProject_IsResumable_AcrossRandomFailures()
         createdEntries.Select(e => e.LexemeForm["en"]).Should().BeEquivalentTo(expectedEntries.Select(e => e.LexemeForm["en"]));
         createdMorphTypes.Select(e => e.Name["en"]).Should().BeEquivalentTo(expectedMorphTypes.Select(e => e.Name["en"]));
         createdMorphTypes.Select(e => e.Kind).Should().BeEquivalentTo(expectedMorphTypes.Select(e => e.Kind));
-
     }
 
 

backend/FwLite/FwLiteProjectSync.Tests/ProjectSnapshotSerializationTests.cs

@@ -54,6 +54,7 @@ public async Task AssertSena3Snapshots(string sourceSnapshotName)
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task LatestSena3SnapshotRoundTrips()
     {
         // arrange

backend/FwLite/FwLiteProjectSync.Tests/Sena3SyncTests.cs

@@ -96,6 +96,35 @@ private async Task WorkaroundMissingWritingSystems()
 
     }
 
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task CanonicalMorphTypes_MatchFwDataMorphTypes()
+    {
+        var fwDataMorphTypes = await _fwDataApi.GetMorphTypes().ToArrayAsync();
+        fwDataMorphTypes.Should().NotBeEmpty("Sena 3 should have morph types");
+
+        // Verify every FwData morph type has a matching canonical entry
+        foreach (var fwMorphType in fwDataMorphTypes)
+        {
+            fwMorphType.Kind.Should().NotBe(MorphTypeKind.Unknown);
+
+            CanonicalMorphTypes.All.Should().ContainKey(fwMorphType.Kind,
+                $"canonical morph types should include {fwMorphType.Kind}");
+            var canonical = CanonicalMorphTypes.All[fwMorphType.Kind];
+            canonical.Id.Should().Be(fwMorphType.Id, $"GUID for {fwMorphType.Kind} should match FwData");
+            canonical.Prefix.Should().Be(fwMorphType.Prefix, $"Prefix for {fwMorphType.Kind} should match FwData");
+            canonical.Postfix.Should().Be(fwMorphType.Postfix, $"Postfix for {fwMorphType.Kind} should match FwData");
+            canonical.SecondaryOrder.Should().Be(fwMorphType.SecondaryOrder, $"SecondaryOrder for {fwMorphType.Kind} should match FwData");
+        }
+
+        // Verify every canonical morph type exists in FwData (no extras we shouldn't have)
+        var fwDataKinds = fwDataMorphTypes
+            .Select(m => m.Kind)
+            .ToHashSet();
+        CanonicalMorphTypes.All.Keys.Should().BeEquivalentTo(fwDataKinds,
+            "every canonical morph type should exist in the Sena 3 FwData project");
+    }
+
     [Fact]
     [Trait("Category", "Integration")]
     public async Task DryRunImport_MakesNoChanges()
@@ -207,6 +236,7 @@ public async Task SecondSena3SyncDoesNothing()
     /// </summary>
     [Fact]
     [Trait("Category", "Integration")]
+    [Trait("Category", "Verified")]
     public async Task LiveSena3Sync()
     {
         // arrange - put "live" crdt db and fw-headless snapshot in place

backend/FwLite/FwLiteProjectSync.Tests/SyncTests.cs

@@ -678,4 +678,32 @@ public async Task CanCreateAComplexFormTypeAndSyncsIt()
 
         _fixture.FwDataApi.GetComplexFormTypes().ToBlockingEnumerable().Should().ContainEquivalentOf(complexFormEntry);
     }
+
+    [Fact]
+    [Trait("Category", "Integration")]
+    public async Task SyncWithLegacySnapshot_EmptyMorphTypes_DoesNotDuplicate()
+    {
+        var crdtApi = _fixture.CrdtApi;
+        var fwdataApi = _fixture.FwDataApi;
+
+        // First sync: import so both sides have data
+        await _syncService.Import(crdtApi, fwdataApi);
+        var snapshot = await _fixture.RegenerateAndGetSnapshot();
+
+        // Simulate a legacy snapshot by clearing MorphTypes
+        var legacySnapshot = snapshot with { MorphTypes = [] };
+
+        // The CRDT should already have morph types (from seeding in MigrateDb).
+        // Syncing with a legacy snapshot should patch the snapshot and not duplicate morph types.
+        var syncResult = await _syncService.Sync(crdtApi, fwdataApi, legacySnapshot);
+
+        // Verify no duplicates
+        var crdtMorphTypes = await crdtApi.GetMorphTypes().ToArrayAsync();
+        crdtMorphTypes.Should().OnlyHaveUniqueItems(mt => mt.Kind);
+        crdtMorphTypes.Should().NotBeEmpty();
+
+        // Verify no morph-type changes were needed (they were patched from CRDT)
+        syncResult.CrdtChanges.Should().Be(0);
+        syncResult.FwdataChanges.Should().Be(0);
+    }
 }

backend/FwLite/FwLiteProjectSync/CrdtFwdataProjectSyncService.cs

@@ -76,6 +76,18 @@ private async Task<SyncResult> SyncOrImportInternal(IMiniLcmApi crdtApi, IMiniLc
         {
             // Repair any missing translation IDs before doing the full sync, so the sync doesn't have to deal with them
             var syncedIdCount = await CrdtRepairs.SyncMissingTranslationIds(projectSnapshot.Entries, fwdata, crdt, dryRun);
+
+            // Patch legacy snapshots that were created before morph-type support.
+            // After seeding, the CRDT has morph-types but the snapshot still has [].
+            // Without this patch, the diff would see all morph-types as "new" and try to re-add them.
+            if (projectSnapshot.MorphTypes.Length == 0)
+            {
+                var currentCrdtMorphTypes = await crdt.GetMorphTypes().ToArrayAsync();
+                if (currentCrdtMorphTypes.Length > 0)
+                {
+                    projectSnapshot = projectSnapshot with { MorphTypes = currentCrdtMorphTypes };
+                }
+            }
         }
 
         var syncResult = projectSnapshot is null

backend/FwLite/LcmCrdt.Tests/Changes/ChangeSerializationTests.cs

@@ -124,6 +124,7 @@ public void CanDeserializeLegacyRegressionData()
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task RegressionDataUpToDate()
     {
         var legacyJsonArray = ReadJsonArrayFromFile(GetJsonFilePath("ChangeDeserializationRegressionData.legacy.verified.txt"));

backend/FwLite/LcmCrdt.Tests/Data/FilteringTests.cs

@@ -12,9 +12,9 @@ public FilteringTests()
         _entries =
         [
             new Entry { LexemeForm = { { "en", "123" } }, },
-            new Entry { LexemeForm = { { "en", "456" } }, }
+            new Entry { LexemeForm = { { "en", "456" } }, },
         ];
-        _morphTypes = new MorphType[] { new() { Id = Guid.NewGuid(), Kind = MorphTypeKind.Stem, Name = { ["en"] = "Stem" }, SecondaryOrder = 1 } }.AsQueryable();
+        _morphTypes = CanonicalMorphTypes.All.Values.ToArray().AsQueryable();
     }
 
     [Theory]

backend/FwLite/LcmCrdt.Tests/Data/MigrationTests.cs

@@ -22,6 +22,7 @@ public class MigrationTests : IAsyncLifetime
     internal static void Init()
     {
         VerifySystemJson.Initialize();
+        VerifierSettings.OmitContentFromException();
     }
 
     public Task InitializeAsync()
@@ -54,6 +55,7 @@ public async Task GetEntries_WorksAfterMigrationFromScriptedDb(RegressionTestHel
     [Theory]
     [InlineData(RegressionTestHelper.RegressionVersion.v1)]
     [InlineData(RegressionTestHelper.RegressionVersion.v2)]
+    [Trait("Category", "Verified")]
     public async Task VerifyAfterMigrationFromScriptedDb(RegressionTestHelper.RegressionVersion regressionVersion)
     {
         await _helper.InitializeAsync(regressionVersion);
@@ -105,6 +107,7 @@ await Task.WhenAll(
     [Theory]
     [InlineData(RegressionTestHelper.RegressionVersion.v1)]
     [InlineData(RegressionTestHelper.RegressionVersion.v2)]
+    [Trait("Category", "Verified")]
     public async Task VerifyRegeneratedSnapshotsAfterMigrationFromScriptedDb(RegressionTestHelper.RegressionVersion regressionVersion)
     {
         await _helper.InitializeAsync(regressionVersion);

backend/FwLite/LcmCrdt.Tests/Data/RegressionTestHelper.cs

@@ -73,6 +73,7 @@ private static string GetFilePath(string name, [CallerFilePath] string sourceFil
     public enum RegressionVersion
     {
         v1,
-        v2
+        v2,
+        v3
     }
 }

backend/FwLite/LcmCrdt.Tests/Data/SnapshotDeserializationTests.cs

@@ -91,6 +91,7 @@ public void CanDeserializeLegacyRegressionData()
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task RegressionDataUpToDate()
     {
         var legacyJsonArray = ReadJsonArrayFromFile(GetJsonFilePath("SnapshotDeserializationRegressionData.legacy.verified.txt"));

backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.cs

@@ -54,24 +54,28 @@ public async Task DisposeAsync()
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task VerifyDbModel()
     {
         await Verify(_crdtDbContext.Model.ToDebugString(MetadataDebugStringOptions.LongDefault));
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task VerifyChangeModels()
     {
         await Verify(_jsonSerializerOptions.GetTypeInfo(typeof(IChange)).PolymorphismOptions);
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task VerifyIObjectBaseModels()
     {
         await Verify(_jsonSerializerOptions.GetTypeInfo(typeof(IObjectBase)).PolymorphismOptions);
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task VerifyIObjectWithIdModels()
     {
         await Verify(_jsonSerializerOptions.GetTypeInfo(typeof(IObjectWithId)).PolymorphismOptions);

backend/FwLite/LcmCrdt.Tests/FullTextSearch/EntrySearchServiceTests.cs

@@ -81,6 +81,7 @@ public async Task UpdateEntrySearchTableEnumerable_DoesNotCreateDuplicates()
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task SearchTableIsUpdatedAutomaticallyOnInsert()
     {
         var id = Guid.NewGuid();
@@ -117,6 +118,7 @@ public async Task SearchTableIsUpdatedAutomaticallyOnInsert()
     }
 
     [Fact]
+    [Trait("Category", "Verified")]
     public async Task SearchTableIsUpdatedAutomaticallyOnUpdate()
     {
         var id = Guid.NewGuid();

backend/FwLite/LcmCrdt.Tests/MiniLcmApiFixture.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using LcmCrdt.MediaServer;
+using LcmCrdt.Objects;
 using Meziantou.Extensions.Logging.Xunit;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
@@ -71,9 +72,11 @@ public async Task InitializeAsync(string projectName)
         _crdtDbContext = await _services.ServiceProvider.GetRequiredService<IDbContextFactory<LcmCrdtDbContext>>().CreateDbContextAsync();
         await _crdtDbContext.Database.OpenConnectionAsync();
         //can't use ProjectsService.CreateProject because it opens and closes the db context, this would wipe out the in memory db.
+        var projectData = new ProjectData("Sena 3", projectName, Guid.NewGuid(), null, Guid.NewGuid());
         await CrdtProjectsService.InitProjectDb(_crdtDbContext,
-            new ProjectData("Sena 3", projectName, Guid.NewGuid(), null, Guid.NewGuid()));
+            projectData);
         await currentProjectService.RefreshProjectData();
+        await PreDefinedData.PredefinedMorphTypes(_services.ServiceProvider.GetRequiredService<DataModel>(), projectData.ClientId);
         if (_seedWs)
         {
             await Api.CreateWritingSystem(new WritingSystem()

backend/FwLite/LcmCrdt.Tests/MiniLcmTests/SortingTests.cs

@@ -24,19 +24,10 @@ public override async Task DisposeAsync()
     [InlineData("a", SortField.SearchRelevance)] // non-FTS
     public async Task SecondaryOrder_DefaultsToStem(string query, SortField sortField)
     {
-        MorphType[] morphTypes = [
-            new() { Id = Guid.NewGuid(), Kind = MorphTypeKind.Stem, Name = { ["en"] = "Stem" }, SecondaryOrder = 1 },
-            new() { Id = Guid.NewGuid(), Kind = MorphTypeKind.BoundStem, Name = { ["en"] = "BoundStem" }, SecondaryOrder = 2 },
-            new() { Id = Guid.NewGuid(), Kind = MorphTypeKind.Suffix, Name = { ["en"] = "Suffix" }, Postfix = "-", SecondaryOrder = 6 },
-        ];
-
-        foreach (var morphType in morphTypes)
-            await Api.CreateMorphType(morphType);
-
         Entry[] expected = [
-            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Unknown }, // SecondaryOrder defaults to Stem = 1
-            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.BoundStem }, // SecondaryOrder = 2
-            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Suffix }, // SecondaryOrder = 6
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Unknown }, // SecondaryOrder defaults to Stem = 0
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.BoundStem }, // SecondaryOrder = 10
+            new() { Id = Guid.NewGuid(), LexemeForm = { ["en"] = "aaaa" }, MorphType = MorphTypeKind.Suffix }, // SecondaryOrder = 70
         ];
 
         var ids = expected.Select(e => e.Id).ToHashSet();