[temp] trigger ci tests

Author: myieye

src/SIL.Harmony.Tests/SnapshotTests.cs

@@ -1,4 +1,6 @@
 using SIL.Harmony.Sample.Models;
+using SIL.Harmony.Sample.Changes;
+using SIL.Harmony.Changes;
 using Microsoft.EntityFrameworkCore;
 
 namespace SIL.Harmony.Tests;
@@ -19,7 +21,7 @@ public async Task MultipleChangesPreservesRootSnapshot()
     {
         var entityId = Guid.NewGuid();
         var commits = new List<Commit>();
-        for (int i = 0; i < 4; i++)
+        for (var i = 0; i < 4; i++)
         {
             commits.Add(await WriteChange(_localClientId,
                 new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero).AddHours(i),
@@ -39,7 +41,7 @@ public async Task MultipleChangesPreservesSomeIntermediateSnapshots()
     {
         var entityId = Guid.NewGuid();
         var commits = new List<Commit>();
-        for (int i = 0; i < 6; i++)
+        for (var i = 0; i < 6; i++)
         {
             commits.Add(await WriteChange(_localClientId,
                 new DateTimeOffset(2000, 1, 1, 0, 0, 0, TimeSpan.Zero).AddHours(i),
@@ -135,7 +137,7 @@ await WriteNextChange(
         var tagCreation = await WriteNextChange(TagWord(wordId, tagId));
         await WriteChangeBefore(tagCreation, TagWord(wordId, tagId));
 
-        var word = await DataModel.QueryLatest<Word>(q=> q.Include(w => w.Tags)
+        var word = await DataModel.QueryLatest<Word>(q => q.Include(w => w.Tags)
             .Where(w => w.Id == wordId)).FirstOrDefaultAsync();
         word.Should().NotBeNull();
         word.Tags.Should().BeEquivalentTo([new Tag { Id = tagId, Text = "tag-1" }]);
@@ -161,4 +163,70 @@ public async Task RegenerateSnapshots_WillArriveAtTheSameState()
         //we probably won't have the same number of snapshots, which is ok. but none of the ids should be the same
         afterSnapshotsIds.Should().NotIntersectWith(beforeSnapshotIds);
     }
+
+    [Fact]
+    public async Task CanApplyChangeToDeletedEntityWithSupportsNewEntity()
+    {
+        var entityId = Guid.NewGuid();
+
+        // Create a word with SetWordTextChange (which supports both NewEntity and ApplyChange)
+        await WriteNextChange(new SetWordTextChange(entityId, "original"));
+        var word = await DataModel.GetLatest<Word>(entityId);
+        word.Should().NotBeNull();
+        word!.Text.Should().Be("original");
+        word.DeletedAt.Should().BeNull();
+
+        // Delete the word
+        await WriteNextChange(DeleteWord(entityId));
+        var deletedWord = await DataModel.GetLatest<Word>(entityId);
+        deletedWord.Should().NotBeNull("deleted entities should still exist in snapshots");
+        deletedWord!.DeletedAt.Should().NotBeNull();
+
+        // Apply change to deleted entity using SetWordTextChange (which SupportsNewEntity)
+        await WriteNextChange(new SetWordTextChange(entityId, "modified while deleted"));
+        var modifiedWord = await DataModel.GetLatest<Word>(entityId);
+        modifiedWord.Should().NotBeNull("change should be applied to deleted entity");
+        modifiedWord!.Text.Should().Be("modified while deleted", "text should be updated");
+        modifiedWord.DeletedAt.Should().NotBeNull("entity should still be marked as deleted since SetWordTextChange doesn't clear DeletedAt");
+    }
+
+    [Fact]
+    public async Task SupportsNewEntityAllowsUpdatingDeletedEntities()
+    {
+        var entityId = Guid.NewGuid();
+
+        // Create and delete
+        await WriteNextChange(new SetWordTextChange(entityId, "original"));
+        await WriteNextChange(DeleteWord(entityId));
+
+        var deletedWord = await DataModel.GetLatest<Word>(entityId);
+        deletedWord.Should().NotBeNull("deleted entity should exist");
+        deletedWord!.DeletedAt.Should().NotBeNull("entity should be deleted");
+
+        // Update deleted entity using SetWordTextChange (which SupportsNewEntity)
+        await WriteNextChange(new SetWordTextChange(entityId, "updated while deleted"));
+
+        var finalWord = await DataModel.GetLatest<Word>(entityId);
+        finalWord.Should().NotBeNull();
+        finalWord!.Text.Should().Be("updated while deleted", "text should be updated");
+        finalWord.DeletedAt.Should().NotBeNull("entity should still be marked as deleted");
+    }
+
+    [Fact]
+    public void SupportsNewEntityMethodIndicatesChangeCapability()
+    {
+        // Test that different change types report their SupportsNewEntity capability correctly
+        var setWordChange = new SetWordTextChange(Guid.NewGuid(), "test");
+        var newWordChange = new NewWordChange(Guid.NewGuid(), "test");
+        var deleteChange = new DeleteChange<Word>(Guid.NewGuid());
+
+        // SetWordTextChange is NOT a CreateChange<T> so it returns false even though it can create entities
+        setWordChange.SupportsNewEntity().Should().BeFalse("SetWordTextChange is not a CreateChange<T>");
+
+        // NewWordChange (CreateChange) supports new entity creation but not applying to existing entities
+        newWordChange.SupportsNewEntity().Should().BeTrue("NewWordChange can create new entities");
+
+        // DeleteChange doesn't support new entity creation (only applies to existing entities)
+        deleteChange.SupportsNewEntity().Should().BeFalse("DeleteChange cannot create new entities");
+    }
 }

src/SIL.Harmony/Changes/Change.cs

@@ -16,6 +16,8 @@ public interface IChange
 
     ValueTask ApplyChange(IObjectBase entity, IChangeContext context);
     ValueTask<IObjectBase> NewEntity(Commit commit, IChangeContext context);
+    bool SupportsApplyChange();
+    bool SupportsNewEntity();
 }
 
 /// <summary>
@@ -44,7 +46,7 @@ async ValueTask<IObjectBase> IChange.NewEntity(Commit commit, IChangeContext con
 
     public async ValueTask ApplyChange(IObjectBase entity, IChangeContext context)
     {
-        if (this is CreateChange<T>)
+        if (!SupportsApplyChange())
             return; // skip attempting to apply changes on CreateChange as it does not support apply changes
         if (entity.DbObject is T entityT)
         {
@@ -56,6 +58,16 @@ public async ValueTask ApplyChange(IObjectBase entity, IChangeContext context)
         }
     }
 
+    public virtual bool SupportsApplyChange()
+    {
+        return this is not CreateChange<T>;
+    }
+
+    public virtual bool SupportsNewEntity()
+    {
+        return this is not EditChange<T>;
+    }
+
     [JsonIgnore]
     public Type EntityType => typeof(T);
 }

src/SIL.Harmony/SnapshotWorker.cs

@@ -81,26 +81,37 @@ private async ValueTask ApplyCommitChanges(IEnumerable<Commit> commits, bool upd
                 IObjectBase entity;
                 var prevSnapshot = await GetSnapshot(commitChange.EntityId);
                 var changeContext = new ChangeContext(commit, commitIndex, intermediateSnapshots, this, _crdtConfig);
-                bool wasDeleted;
-                if (prevSnapshot is not null)
+
+                if (prevSnapshot is null)
                 {
-                    entity = prevSnapshot.Entity.Copy();
-                    wasDeleted = entity.DeletedAt.HasValue;
+                    // create brand new entity
+                    entity = await commitChange.Change.NewEntity(commit, changeContext);
                 }
-                else
+                else if (prevSnapshot.EntityIsDeleted && commitChange.Change.SupportsNewEntity())
                 {
+                    // revive deleted entity
                     entity = await commitChange.Change.NewEntity(commit, changeContext);
-                    wasDeleted = false;
                 }
-
-                await commitChange.Change.ApplyChange(entity, changeContext);
-
-                var deletedByChange = !wasDeleted && entity.DeletedAt.HasValue;
-                if (deletedByChange)
+                else if (commitChange.Change.SupportsApplyChange())
                 {
-                    await MarkDeleted(entity.Id, changeContext);
+                    // update existing entity
+                    entity = prevSnapshot.Entity.Copy();
+                    var wasDeleted = prevSnapshot.EntityIsDeleted;
+                    await commitChange.Change.ApplyChange(entity, changeContext);
+                    var deletedByChange = !wasDeleted && entity.DeletedAt.HasValue;
+                    if (deletedByChange)
+                    {
+                        await MarkDeleted(entity.Id, changeContext);
+                    }
                 }
-                
+                else
+                {
+                    // entity already exists (and is not deleted)
+                    // and change does not support updating existing entities
+                    // so do nothing
+                    continue;
+                }
+
                 await GenerateSnapshotForEntity(entity, prevSnapshot, changeContext);
             }
             _newIntermediateSnapshots.AddRange(intermediateSnapshots.Values);