NullReferenceException when trying to seed a keyless entity #23030

src/EFCore/Infrastructure/ModelValidator.cs

@@ -994,6 +994,10 @@ protected virtual void ValidateData([NotNull] IModel model, [NotNull] IDiagnosti
                 var key = entityType.FindPrimaryKey();
                 if (key == null)
                 {
+                    if (entityType.GetSeedData().Any())
+                    {
+                        throw new InvalidOperationException(CoreStrings.SeedKeylessEntity(entityType.DisplayName()));
+                    }
                     continue;
                 }
 

src/EFCore/Properties/CoreStrings.resx

@@ -1318,6 +1318,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 or removing the seed data.</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>
@@ -1464,4 +1467,4 @@
   <data name="WrongStateManager" xml:space="preserve">
     <value>Cannot start tracking the entry for entity type '{entityType}' because it was created by a different StateManager instance.</value>
   </data>
-</root>
+</root>

test/EFCore.InMemory.FunctionalTests/SeedingInMemoryTest.cs

@@ -1,13 +1,20 @@
 // 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 Microsoft.EntityFrameworkCore.TestUtilities;
+
 namespace Microsoft.EntityFrameworkCore
 {
     public class SeedingInMemoryTest : SeedingTestBase
     {
+        protected override TestStore TestStore => InMemoryTestStore.Create("inMemoryTestStore");
+
         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)
@@ -18,5 +25,16 @@ public SeedingInMemoryContext(string 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($"KeylessSeeds{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;
 
@@ -17,6 +19,7 @@ public abstract class SeedingTestBase
         public virtual async Task Seeding_does_not_leave_context_contaminated(bool async)
         {
             using var context = CreateContextWithEmptyDatabase(async ? "1A" : "1S");
+            TestStore.Clean(context);
             var _ = async
                 ? await context.Database.EnsureCreatedResilientlyAsync()
                 : context.Database.EnsureCreatedResiliently();
@@ -31,8 +34,29 @@ 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");
+                    TestStore.Clean(context);
+                    var _ = async
+                        ? await context.Database.EnsureCreatedResilientlyAsync()
+                        : context.Database.EnsureCreatedResiliently();
+                });
+            Assert.Equal(CoreStrings.SeedKeylessEntity(nameof(KeylessSeed)), exception.Message);
+        }
+
+        protected abstract TestStore TestStore { get; }
+
         protected abstract SeedingContext CreateContextWithEmptyDatabase(string testId);
 
+        protected abstract KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId);
+
         protected abstract class SeedingContext : DbContext
         {
             public string TestId { get; }
@@ -54,5 +78,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,20 +1,22 @@
 // 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
 {
     public class SeedingSqlServerTest : SeedingTestBase
     {
-        protected override SeedingContext CreateContextWithEmptyDatabase(string testId)
-        {
-            var context = new SeedingSqlServerContext(testId);
+        protected override TestStore TestStore => SqlServerTestStore.Create("sqlServerTestStore");
 
-            context.Database.EnsureClean();
+        protected override SeedingContext CreateContextWithEmptyDatabase(string testId)
+            => new SeedingSqlServerContext(testId);
 
-            return context;
-        }
+        protected override KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId)
+            => new KeylessSeedingSqlServerContext(testId);
 
         protected class SeedingSqlServerContext : SeedingContext
         {
@@ -26,5 +28,15 @@ public SeedingSqlServerContext(string testId)
             protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
                 => optionsBuilder.UseSqlServer(SqlServerTestStore.CreateConnectionString($"Seeds{TestId}"));
         }
+        protected class KeylessSeedingSqlServerContext : KeylessSeedingContext
+        {
+            public KeylessSeedingSqlServerContext(string testId)
+                : base(testId)
+            {
+            }
+
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder.UseSqlServer(SqlServerTestStore.CreateConnectionString($"KeylessSeeds{TestId}"));
+        }
     }
 }

test/EFCore.Sqlite.FunctionalTests/SeedingSqliteTest.cs

@@ -1,18 +1,19 @@
 // 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 Microsoft.EntityFrameworkCore.TestUtilities;
+
 namespace Microsoft.EntityFrameworkCore
 {
     public class SeedingSqliteTest : SeedingTestBase
     {
+        protected override TestStore TestStore => SqliteTestStore.Create("sqlliteTestStore");
+
         protected override SeedingContext CreateContextWithEmptyDatabase(string testId)
-        {
-            var context = new SeedingSqliteContext(testId);
+            => new SeedingSqliteContext(testId);
 
-            context.Database.EnsureClean();
-
-            return context;
-        }
+        protected override KeylessSeedingContext CreateKeylessContextWithEmptyDatabase(string testId)
+            => new KeylessSeedingSqliteContext(testId);
 
         protected class SeedingSqliteContext : SeedingContext
         {
@@ -24,5 +25,16 @@ public SeedingSqliteContext(string testId)
             protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
                 => optionsBuilder.UseSqlite(($"Data Source = Seeds{TestId}.db"));
         }
+
+        protected class KeylessSeedingSqliteContext : KeylessSeedingContext
+        {
+            public KeylessSeedingSqliteContext(string testId)
+                : base(testId)
+            {
+            }
+
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder.UseSqlite(($"Data Source = KeylessSeeds{TestId}.db"));
+        }
     }
 }

test/EFCore.Tests/Infrastructure/ModelValidatorTest.cs

@@ -1332,6 +1332,24 @@ public virtual void Shared_type_inheritance_throws()
             VerifyError(CoreStrings.SharedTypeDerivedType("Shared2 (C)"), modelBuilder.Model);
         }
 
+        [ConditionalFact]
+        public virtual void Seeding_keyless_entity_throws()
+        {
+            var modelBuilder = CreateConventionalModelBuilder();
+            modelBuilder.Entity<KeylessSeed>(
+                e =>
+                {
+                    e.HasNoKey();
+                    e.HasData(
+                        new KeylessSeed
+                        {
+                            Species = "Apple"
+                        });
+                });
+
+            VerifyError(CoreStrings.SeedKeylessEntity(nameof(KeylessSeed)), modelBuilder.Model);
+        }
+
         // INotify interfaces not really implemented; just marking the classes to test metadata construction
         private class FullNotificationEntity : INotifyPropertyChanging, INotifyPropertyChanged
         {

test/EFCore.Tests/Infrastructure/ModelValidatorTestBase.cs

@@ -247,6 +247,11 @@ protected class Product
             public virtual ICollection<Order> Orders { get; set; }
         }
 
+        protected class KeylessSeed
+        {
+            public string Species { get; set; }
+        }
+
         protected ModelValidatorTestBase()
             => LoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Validation.Name || l == DbLoggerCategory.Model.Name);