Add tests for entity linking with generated and client-generated keys

Co-authored-by: PhenX <42170+PhenX@users.noreply.github.com>

Author: Copilot

tests/PhenX.EntityFrameworkCore.BulkInsert.Tests/Tests/Graph/GraphTestsBase.cs

@@ -434,4 +434,158 @@ await _context.ExecuteBulkInsertAsync(new[] { blog }, options =>
         insertedTags.Should().HaveCount(2);
         insertedTags.Should().AllSatisfy(t => t.Id.Should().BeGreaterThan(0));
     }
+
+    [SkippableFact]
+    public async Task InsertGraph_OriginalEntitiesLinked_WithGeneratedKeys()
+    {
+        // Arrange - Keep references to original entities
+        var post1 = new Post { TestRun = _run, Title = $"{_run}_LinkedPost1" };
+        var post2 = new Post { TestRun = _run, Title = $"{_run}_LinkedPost2" };
+        var settings = new BlogSettings { TestRun = _run, EnableComments = true };
+        var blog = new Blog
+        {
+            TestRun = _run,
+            Name = $"{_run}_LinkedBlog",
+            Posts = new List<Post> { post1, post2 },
+            Settings = settings
+        };
+
+        // Act
+        await _context.ExecuteBulkInsertAsync(new[] { blog }, options =>
+        {
+            options.IncludeGraph = true;
+        });
+
+        // Assert - Verify the original entity references are the same objects
+        // and have their generated IDs populated
+        blog.Id.Should().BeGreaterThan(0, "Blog should have generated ID populated");
+        post1.Id.Should().BeGreaterThan(0, "Post1 should have generated ID populated");
+        post2.Id.Should().BeGreaterThan(0, "Post2 should have generated ID populated");
+        settings.Id.Should().BeGreaterThan(0, "Settings should have generated ID populated");
+
+        // Verify FK values are propagated
+        post1.BlogId.Should().Be(blog.Id, "Post1.BlogId should reference the Blog");
+        post2.BlogId.Should().Be(blog.Id, "Post2.BlogId should reference the Blog");
+        settings.BlogId.Should().Be(blog.Id, "Settings.BlogId should reference the Blog");
+
+        // Verify the same objects are in the collections
+        blog.Posts.Should().Contain(post1, "Original post1 reference should still be in the collection");
+        blog.Posts.Should().Contain(post2, "Original post2 reference should still be in the collection");
+        blog.Settings.Should().BeSameAs(settings, "Original settings reference should still be assigned");
+
+        // Verify data matches what's in the database
+        var dbBlog = _context.Blogs.FirstOrDefault(b => b.Id == blog.Id);
+        dbBlog.Should().NotBeNull();
+        dbBlog!.Name.Should().Be(blog.Name);
+
+        var dbPosts = _context.Posts.Where(p => p.BlogId == blog.Id).ToList();
+        dbPosts.Should().HaveCount(2);
+        dbPosts.Select(p => p.Id).Should().Contain(post1.Id);
+        dbPosts.Select(p => p.Id).Should().Contain(post2.Id);
+    }
+
+    [SkippableFact]
+    public async Task InsertGraph_OriginalEntitiesLinked_WithClientGeneratedKeys()
+    {
+        // Arrange - Create entities with pre-set GUIDs (client-generated keys)
+        // Using TestEntityWithGuidId which has ValueGeneratedNever()
+        var guid1 = Guid.NewGuid();
+        var guid2 = Guid.NewGuid();
+
+        var entity1 = new TestEntityWithGuidId
+        {
+            TestRun = _run,
+            Id = guid1,
+            Name = $"{_run}_ClientGenKey1"
+        };
+        var entity2 = new TestEntityWithGuidId
+        {
+            TestRun = _run,
+            Id = guid2,
+            Name = $"{_run}_ClientGenKey2"
+        };
+
+        // Act - Insert without graph (since these don't have navigations)
+        // but test that client-generated keys are preserved
+        await _context.ExecuteBulkInsertAsync(new[] { entity1, entity2 }, options =>
+        {
+            // No IncludeGraph needed since no navigations
+        });
+
+        // Assert - Verify the original entity references maintain their IDs
+        entity1.Id.Should().Be(guid1, "Entity1 should retain its client-generated ID");
+        entity2.Id.Should().Be(guid2, "Entity2 should retain its client-generated ID");
+
+        // Verify data is in database with the same IDs
+        var dbEntity1 = _context.TestEntitiesWithGuidId.FirstOrDefault(e => e.Id == guid1);
+        var dbEntity2 = _context.TestEntitiesWithGuidId.FirstOrDefault(e => e.Id == guid2);
+
+        dbEntity1.Should().NotBeNull();
+        dbEntity2.Should().NotBeNull();
+        dbEntity1!.Name.Should().Be(entity1.Name);
+        dbEntity2!.Name.Should().Be(entity2.Name);
+    }
+
+    [SkippableFact]
+    public async Task InsertGraph_MultipleRootEntities_OriginalEntitiesLinked()
+    {
+        // Arrange - Multiple root entities with children, keep all references
+        var post1 = new Post { TestRun = _run, Title = $"{_run}_Multi1Post1" };
+        var post2 = new Post { TestRun = _run, Title = $"{_run}_Multi2Post1" };
+        var post3 = new Post { TestRun = _run, Title = $"{_run}_Multi2Post2" };
+
+        var blog1 = new Blog
+        {
+            TestRun = _run,
+            Name = $"{_run}_MultiBlogLinked1",
+            Posts = new List<Post> { post1 }
+        };
+        var blog2 = new Blog
+        {
+            TestRun = _run,
+            Name = $"{_run}_MultiBlogLinked2",
+            Posts = new List<Post> { post2, post3 }
+        };
+
+        var blogs = new[] { blog1, blog2 };
+
+        // Act
+        await _context.ExecuteBulkInsertAsync(blogs, options =>
+        {
+            options.IncludeGraph = true;
+        });
+
+        // Assert - All original entities should have IDs and be linked correctly
+        blog1.Id.Should().BeGreaterThan(0);
+        blog2.Id.Should().BeGreaterThan(0);
+        blog1.Id.Should().NotBe(blog2.Id, "Different blogs should have different IDs");
+
+        post1.Id.Should().BeGreaterThan(0);
+        post2.Id.Should().BeGreaterThan(0);
+        post3.Id.Should().BeGreaterThan(0);
+        post1.Id.Should().NotBe(post2.Id);
+        post2.Id.Should().NotBe(post3.Id);
+
+        // Verify FK relationships
+        post1.BlogId.Should().Be(blog1.Id);
+        post2.BlogId.Should().Be(blog2.Id);
+        post3.BlogId.Should().Be(blog2.Id);
+
+        // Verify original objects are still in collections
+        blog1.Posts.Should().Contain(post1);
+        blog2.Posts.Should().Contain(post2);
+        blog2.Posts.Should().Contain(post3);
+
+        // Verify database state matches
+        var dbBlogs = _context.Blogs.Where(b => b.TestRun == _run).ToList();
+        dbBlogs.Should().HaveCount(2);
+        dbBlogs.Select(b => b.Id).Should().Contain(blog1.Id);
+        dbBlogs.Select(b => b.Id).Should().Contain(blog2.Id);
+
+        var dbPosts = _context.Posts.Where(p => p.TestRun == _run).ToList();
+        dbPosts.Should().HaveCount(3);
+        dbPosts.Select(p => p.Id).Should().Contain(post1.Id);
+        dbPosts.Select(p => p.Id).Should().Contain(post2.Id);
+        dbPosts.Select(p => p.Id).Should().Contain(post3.Id);
+    }
 }