EF Core pattern coverage sweep: 44 new tests across 10 common LINQ-to-SQL patterns — value converters, many-to-many, global query filters, eager / split queries (Include / ThenInclude / AsSplitQuery), owned entities (OwnsOne / OwnsMany), shadow properties + alternate keys, concurrency tokens ([Timestamp] rowversion + DbUpdateConcurrencyException), ExecuteUpdate / ExecuteDelete bulk operations, stored procedure CRUD mappings (InsertUsingStoredProcedure / UpdateUsingStoredProcedure / DeleteUsingStoredProcedure), and temporal tables (IsTemporal + TemporalAsOf / TemporalAll). 38 tests pass against the existing simulator; 6 disabled with [Ignore("Needs: <category>")] tags marking next-arc work: ExecuteUpdate column-self-reference (2 tests covering SetProperty(col, c => c.col + 1) form) and temporal-table DDL + history tracking + FOR SYSTEM_TIME queries (4 tests covering GENERATED ALWAYS AS ROW START/END / PERIOD FOR SYSTEM_TIME / WITH (SYSTEM_VERSIONING = ON …) / TemporalAsOf / TemporalAll). Test set is the regression oracle for the next arc — unblock tests in category order, starting with whichever pays off fastest in application compatibility.

Author: RyanLamansky

SqlServerSimulator.Tests.EFCore/EFCoreConcurrencyTokens.cs

@@ -0,0 +1,146 @@
+using Microsoft.EntityFrameworkCore;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for EF Core's optimistic-concurrency support via
+/// <c>[Timestamp]</c> rowversion columns. On every UPDATE / DELETE EF
+/// includes the rowversion in the WHERE clause; if the row's stored
+/// rowversion has advanced since the entity was read, the affected-rows
+/// count is 0 and EF throws <see cref="DbUpdateConcurrencyException"/>.
+/// EF also OUTPUTs the new rowversion so the in-memory entity tracks
+/// the latest version after a successful save. Exercises the simulator's
+/// rowversion auto-advance + OUTPUT-INSERTED round-trip + WHERE-on-
+/// rowversion filtering.
+/// </summary>
+[TestClass]
+public class EFCoreConcurrencyTokens
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private sealed class Item
+    {
+        public int Id { get; set; }
+
+        [Column(TypeName = "nvarchar(30)")]
+        public string Name { get; set; } = "";
+
+        public int Quantity { get; set; }
+
+        [Timestamp]
+        public byte[] RowVersion { get; set; } = [];
+    }
+
+    private sealed class InventoryContext(Simulation simulation) : DbContext
+    {
+        public Simulation Simulation { get; } = simulation;
+
+        public DbSet<Item> Items => Set<Item>();
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            _ = optionsBuilder.UseSqlServer(this.Simulation.CreateDbConnection());
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            _ = modelBuilder.Entity<Item>().Property(i => i.Id).ValueGeneratedNever();
+        }
+    }
+
+    private static Simulation CreateSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Items (
+                    Id int not null primary key,
+                    Name nvarchar(30) not null,
+                    Quantity int not null,
+                    RowVersion rowversion not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
+    private static InventoryContext SeededContext()
+    {
+        var context = new InventoryContext(CreateSimulation());
+        context.Items.AddRange(
+            new Item { Id = 1, Name = "widget", Quantity = 10 },
+            new Item { Id = 2, Name = "gadget", Quantity = 5 });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void Insert_PopulatesRowVersion()
+    {
+        using var context = SeededContext();
+        var widget = context.Items.Single(i => i.Id == 1);
+        Assert.IsNotNull(widget.RowVersion);
+        Assert.AreNotEqual(0, widget.RowVersion.Length);
+    }
+
+    [TestMethod]
+    public void Update_AdvancesRowVersion()
+    {
+        using var context = SeededContext();
+        var widget = context.Items.Single(i => i.Id == 1);
+        var before = widget.RowVersion;
+        widget.Quantity = 20;
+        _ = context.SaveChanges();
+        var after = widget.RowVersion;
+        CollectionAssert.AreNotEqual(before, after);
+    }
+
+    [TestMethod]
+    public void StaleUpdate_ThrowsConcurrencyException()
+    {
+        var simulation = CreateSimulation();
+        using (var first = new InventoryContext(simulation))
+        {
+            _ = first.Items.Add(new Item { Id = 1, Name = "widget", Quantity = 10 });
+            _ = first.SaveChanges();
+        }
+
+        using var contextA = new InventoryContext(simulation);
+        using var contextB = new InventoryContext(simulation);
+
+        var widgetA = contextA.Items.Single(i => i.Id == 1);
+        var widgetB = contextB.Items.Single(i => i.Id == 1);
+
+        widgetA.Quantity = 20;
+        _ = contextA.SaveChanges();
+
+        widgetB.Quantity = 30;
+        _ = Assert.Throws<DbUpdateConcurrencyException>(() => contextB.SaveChanges());
+    }
+
+    [TestMethod]
+    public void StaleDelete_ThrowsConcurrencyException()
+    {
+        var simulation = CreateSimulation();
+        using (var first = new InventoryContext(simulation))
+        {
+            _ = first.Items.Add(new Item { Id = 1, Name = "widget", Quantity = 10 });
+            _ = first.SaveChanges();
+        }
+
+        using var contextA = new InventoryContext(simulation);
+        using var contextB = new InventoryContext(simulation);
+
+        var widgetA = contextA.Items.Single(i => i.Id == 1);
+        var widgetB = contextB.Items.Single(i => i.Id == 1);
+
+        widgetA.Quantity = 99;
+        _ = contextA.SaveChanges();
+
+        _ = contextB.Items.Remove(widgetB);
+        _ = Assert.Throws<DbUpdateConcurrencyException>(() => contextB.SaveChanges());
+    }
+}

SqlServerSimulator.Tests.EFCore/EFCoreEagerSplitQueries.cs

@@ -0,0 +1,174 @@
+using Microsoft.EntityFrameworkCore;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end tests for EF Core's eager-loading surface:
+/// <c>Include</c> / <c>ThenInclude</c> walk navigation collections
+/// via LEFT JOIN in a single query (the default). <c>AsSplitQuery()</c>
+/// switches to one query per Include level, avoiding the cartesian-
+/// explosion that JOIN-based eager loading causes with multiple
+/// collection navigations. Both shapes are common in real apps.
+/// </summary>
+[TestClass]
+public class EFCoreEagerSplitQueries
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private sealed class Blog
+    {
+        public int Id { get; set; }
+
+        [Column(TypeName = "nvarchar(50)")]
+        public string Name { get; set; } = "";
+
+        public List<Post> Posts { get; set; } = [];
+    }
+
+    private sealed class Post
+    {
+        public int Id { get; set; }
+
+        [Column(TypeName = "nvarchar(50)")]
+        public string Title { get; set; } = "";
+
+        public int BlogId { get; set; }
+        public Blog? Blog { get; set; }
+
+        public List<Comment> Comments { get; set; } = [];
+    }
+
+    private sealed class Comment
+    {
+        public int Id { get; set; }
+
+        [Column(TypeName = "nvarchar(100)")]
+        public string Text { get; set; } = "";
+
+        public int PostId { get; set; }
+        public Post? Post { get; set; }
+    }
+
+    private sealed class BlogContext(Simulation simulation) : DbContext
+    {
+        public Simulation Simulation { get; } = simulation;
+
+        public DbSet<Blog> Blogs => Set<Blog>();
+        public DbSet<Post> Posts => Set<Post>();
+        public DbSet<Comment> Comments => Set<Comment>();
+
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            _ = optionsBuilder.UseSqlServer(this.Simulation.CreateDbConnection());
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            _ = modelBuilder.Entity<Blog>().Property(b => b.Id).ValueGeneratedNever();
+            _ = modelBuilder.Entity<Post>().Property(p => p.Id).ValueGeneratedNever();
+            _ = modelBuilder.Entity<Comment>().Property(c => c.Id).ValueGeneratedNever();
+        }
+    }
+
+    private static Simulation CreateSimulation()
+    {
+        var simulation = new Simulation();
+        _ = simulation
+            .CreateOpenConnection()
+            .CreateCommand("""
+                create table Blogs (
+                    Id int not null primary key,
+                    Name nvarchar(50) not null
+                );
+                create table Posts (
+                    Id int not null primary key,
+                    Title nvarchar(50) not null,
+                    BlogId int not null
+                );
+                create table Comments (
+                    Id int not null primary key,
+                    Text nvarchar(100) not null,
+                    PostId int not null
+                )
+                """)
+            .ExecuteNonQuery();
+        return simulation;
+    }
+
+    private static BlogContext SeededContext()
+    {
+        var context = new BlogContext(CreateSimulation());
+        _ = context.Blogs.Add(new Blog
+        {
+            Id = 1,
+            Name = "Tech",
+            Posts =
+            {
+                new Post
+                {
+                    Id = 10,
+                    Title = "Hello",
+                    BlogId = 1,
+                    Comments = { new Comment { Id = 100, Text = "first", PostId = 10 } },
+                },
+                new Post
+                {
+                    Id = 11,
+                    Title = "World",
+                    BlogId = 1,
+                    Comments =
+                    {
+                        new Comment { Id = 110, Text = "ok", PostId = 11 },
+                        new Comment { Id = 111, Text = "thanks", PostId = 11 },
+                    },
+                },
+            },
+        });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void Include_LoadsCollectionInSameQuery()
+    {
+        using var context = SeededContext();
+        var blog = context.Blogs.Include(b => b.Posts).Single(b => b.Id == 1);
+        Assert.HasCount(2, blog.Posts);
+        CollectionAssert.AreEquivalent(new[] { "Hello", "World" }, blog.Posts.Select(p => p.Title).ToArray());
+    }
+
+    [TestMethod]
+    public void IncludeThenInclude_LoadsTwoLevels()
+    {
+        using var context = SeededContext();
+        var blog = context.Blogs
+            .Include(b => b.Posts)
+            .ThenInclude(p => p.Comments)
+            .Single(b => b.Id == 1);
+        var totalComments = blog.Posts.Sum(p => p.Comments.Count);
+        Assert.AreEqual(3, totalComments);
+    }
+
+    [TestMethod]
+    public void AsSplitQuery_LoadsCollectionsViaSeparateQueries()
+    {
+        using var context = SeededContext();
+        var blog = context.Blogs
+            .Include(b => b.Posts)
+            .ThenInclude(p => p.Comments)
+            .AsSplitQuery()
+            .Single(b => b.Id == 1);
+        var totalComments = blog.Posts.Sum(p => p.Comments.Count);
+        Assert.AreEqual(3, totalComments);
+    }
+
+    [TestMethod]
+    public void InverseInclude_WalksNonCollectionNavigation()
+    {
+        using var context = SeededContext();
+        var post = context.Posts.Include(p => p.Blog).Single(p => p.Id == 10);
+        Assert.IsNotNull(post.Blog);
+        Assert.AreEqual("Tech", post.Blog!.Name);
+    }
+}