NullReferenceException when trying to seed a keyless entity #23030

src/EFCore/ChangeTracking/Internal/InternalEntityEntry.cs

@@ -1585,7 +1585,11 @@ public virtual bool IsKeyUnknown
         {
             get
             {
-                var keyProperties = ((EntityType)EntityType).FindPrimaryKey().Properties;
+                var keyProperties = ((EntityType)EntityType).FindPrimaryKey()?.Properties;
+                if (keyProperties == null)
+                {
+                    throw new InvalidOperationException(CoreStrings.SeedKeylessEntity(EntityType.DisplayName()));
+                }
                 // ReSharper disable once ForCanBeConvertedToForeach
                 // ReSharper disable once LoopCanBeConvertedToQuery
                 for (var i = 0; i < keyProperties.Count; i++)

src/EFCore/Properties/CoreStrings.resx

@@ -1305,6 +1305,9 @@
   <data name="SeedDatumSignedNumericValue" xml:space="preserve">
     <value>The seed entity for entity type '{entityType}' cannot be added because a non-zero value is required for property '{property}'. Consider providing a negative value to avoid collisions with non-seed data.</value>
   </data>
+  <data name="SeedKeylessEntity" xml:space="preserve">
+    <value>The seed entity for entity type '{entityType}' cannot be added because keyless entity types are not supported. Consider providing a key to seed data or use this entity for query only.</value>
+  </data>
   <data name="SelfReferencingNavigationWithInverseProperty" xml:space="preserve">
     <value>The inverse for the navigation '{entityType}.{property}' cannot be the same navigation. Change the value in the [InverseProperty] attribute to a different navigation.</value>
   </data>

test/EFCore.InMemory.FunctionalTests/SeedingInMemoryTest.cs

@@ -8,13 +8,26 @@ public class SeedingInMemoryTest : SeedingTestBase
         protected override SeedingContext CreateContextWithEmptyDatabase(string testId)
             => new SeedingInMemoryContext(testId);
 
+        protected override KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId)
+        => new KeylessSeedingInMemoryContext(testId);
+
         protected class SeedingInMemoryContext : SeedingContext
         {
             public SeedingInMemoryContext(string testId)
                 : base(testId)
             {
             }
 
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder.UseInMemoryDatabase($"Seeds{TestId}");
+        }
+        protected class KeylessSeedingInMemoryContext : KeylessSeedingContext
+        {
+            public KeylessSeedingInMemoryContext(string testId)
+                : base(testId)
+            {
+            }
+
             protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
                 => optionsBuilder.UseInMemoryDatabase($"Seeds{TestId}");
         }

test/EFCore.Specification.Tests/SeedingTestBase.cs

@@ -1,9 +1,11 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.ComponentModel.DataAnnotations.Schema;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.TestUtilities;
 using Xunit;
 
@@ -31,8 +33,32 @@ public virtual async Task Seeding_does_not_leave_context_contaminated(bool async
             Assert.Equal("Orange", seeds[1].Species);
         }
 
+        [ConditionalTheory]
+        [InlineData(false)]
+        [InlineData(true)]
+        public virtual async Task Seeding_keyless_entity_throws_exception(bool async)
+        {
+            var exception = await Assert.ThrowsAsync<InvalidOperationException>(
+                async () =>
+                {
+                    using var context = CreateKeylessContextWithEmptyDatabase(async ? "1A" : "1S");
+                    var _ = async
+                        ? await context.Database.EnsureCreatedResilientlyAsync()
+                        : context.Database.EnsureCreatedResiliently();
+
+                    Assert.Empty(context.ChangeTracker.Entries());
+
+                    var seeds = context.Set<KeylessSeed>().OrderBy(e => e.Species).ToList();
+
+                    Assert.Empty(seeds);
+                });
+            Assert.Equal(CoreStrings.SeedKeylessEntity(nameof(KeylessSeed)), exception.Message);
+        }
+
         protected abstract SeedingContext CreateContextWithEmptyDatabase(string testId);
 
+        protected abstract KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId);
+
         protected abstract class SeedingContext : DbContext
         {
             public string TestId { get; }
@@ -54,5 +80,26 @@ protected class Seed
 
             public string Species { get; set; }
         }
+
+        protected abstract class KeylessSeedingContext : DbContext
+        {
+            public string TestId { get; }
+
+            protected KeylessSeedingContext(string testId)
+                => TestId = testId;
+
+            protected override void OnModelCreating(ModelBuilder modelBuilder)
+                => modelBuilder.Entity<KeylessSeed>()
+                    .HasNoKey()
+                    .HasData(
+                    new KeylessSeed { Species = "Apple" },
+                    new KeylessSeed { Species = "Orange" }
+                );
+        }
+
+        protected class KeylessSeed
+        {
+            public string Species { get; set; }
+        }
     }
 }

test/EFCore.SqlServer.FunctionalTests/SeedingSqlServerTest.cs

@@ -1,7 +1,10 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.EntityFrameworkCore.TestUtilities;
+using Xunit;
 
 namespace Microsoft.EntityFrameworkCore
 {
@@ -16,6 +19,15 @@ protected override SeedingContext CreateContextWithEmptyDatabase(string testId)
             return context;
         }
 
+        protected override KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId)
+        {
+            var context = new KeylessSeedingInMemoryContext(testId);
+
+            context.Database.EnsureClean();
+
+            return context;
+        }
+
         protected class SeedingSqlServerContext : SeedingContext
         {
             public SeedingSqlServerContext(string testId)
@@ -26,5 +38,16 @@ public SeedingSqlServerContext(string testId)
             protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
                 => optionsBuilder.UseSqlServer(SqlServerTestStore.CreateConnectionString($"Seeds{TestId}"));
         }
+        protected class KeylessSeedingInMemoryContext : KeylessSeedingContext
+        {
+            public KeylessSeedingInMemoryContext(string testId)
+                : base(testId)
+            {
+            }
+
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder.UseSqlServer(SqlServerTestStore.CreateConnectionString($"Seeds{TestId}"));
+        }
+
     }
 }

test/EFCore.Sqlite.FunctionalTests/SeedingSqliteTest.cs

@@ -14,13 +14,32 @@ protected override SeedingContext CreateContextWithEmptyDatabase(string testId)
             return context;
         }
 
+        protected override KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId)
+        {
+            var context = new KeylessSeedingInMemoryContext(testId);
+
+            context.Database.EnsureClean();
+
+            return context;
+        }
+
         protected class SeedingSqliteContext : SeedingContext
         {
             public SeedingSqliteContext(string testId)
                 : base(testId)
             {
             }
 
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder.UseSqlite(($"Data Source = Seeds{TestId}.db"));
+        }
+        protected class KeylessSeedingInMemoryContext : KeylessSeedingContext
+        {
+            public KeylessSeedingInMemoryContext(string testId)
+                : base(testId)
+            {
+            }
+
             protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
                 => optionsBuilder.UseSqlite(($"Data Source = Seeds{TestId}.db"));
         }