Throw a meaningful exception when two objects represent the same docu…

…ment in a session (#601)

src/YesSql.Core/Session.cs

@@ -128,6 +128,15 @@ public async Task SaveAsync(object entity, bool checkConcurrency = false, string
 
                 if (id > 0)
                 {
+                    // If we got an object from a different identity map, without change tracking, the object reference could be different than
+                    // the one in the identity map, and the previous state.IdentityMap.TryGetDocumentId would have returned false.
+                    // In this case we need to assume it's an updated object and not try to "Add" it to the identity map.
+
+                    if (state.IdentityMap.TryGetEntityById(id, out var _))
+                    {
+                        throw new InvalidOperationException("An object with the same identity is already part of this transaction. Reload it before doing any changes on it.");
+                    }
+
                     state.IdentityMap.AddEntity(id, entity);
                     state.Updated.Add(entity);
 

test/YesSql.Tests/CoreTests.cs

@@ -1014,6 +1014,36 @@ public async Task DetachAllRemoveAllEntitiesFromIdentityMap()
             Assert.NotEqual(p3a, p3d);
         }
 
+        [Fact]
+        public async Task SavingRefreshedDocument()
+        {
+            await using var session = _store.CreateSession();
+            var bill = new Person
+            {
+                Firstname = "Bill",
+                Lastname = "Gates"
+            };
+
+            await session.SaveAsync(bill);
+            await session.SaveChangesAsync();
+
+            var newBill1 = await session.GetAsync<Person>(bill.Id);
+            await session.SaveAsync(newBill1);
+            await session.SaveChangesAsync();
+
+            // IdentityMap is cleared after SaveChangesAsync so we should get a new instance
+            var newBill2 = await session.GetAsync<Person>(bill.Id);
+
+            // This should be no-op because newBill1 is tracked
+            await session.SaveAsync(newBill2);
+
+            // Saving an object whose id is already in the identity map should throw an exception
+            // since it shows that two objects representing the same document, with potentially
+            // different changes, would be stored, so some changes would be lost.
+
+            await Assert.ThrowsAsync<InvalidOperationException>(() => session.SaveAsync(newBill1));
+        }
+
         [Fact]
         public async Task ShouldUpdateAutoFlushedIndex()
         {