Ensure warnings configured to throw really do throw with the SQL Server provider

src/EFCore.SqlServer/Extensions/SqlServerDbContextOptionsBuilderExtensions.cs

@@ -192,10 +192,11 @@ var coreOptionsExtension
             = optionsBuilder.Options.FindExtension<CoreOptionsExtension>()
             ?? new CoreOptionsExtension();
 
-        coreOptionsExtension = RelationalOptionsExtension.WithDefaultWarningConfiguration(coreOptionsExtension)
-            .WithWarningsConfiguration(
-                coreOptionsExtension.WarningsConfiguration.TryWithExplicit(
-                    SqlServerEventId.ConflictingValueGenerationStrategiesWarning, WarningBehavior.Throw));
+        coreOptionsExtension = RelationalOptionsExtension.WithDefaultWarningConfiguration(coreOptionsExtension);
+
+        coreOptionsExtension = coreOptionsExtension.WithWarningsConfiguration(
+            coreOptionsExtension.WarningsConfiguration.TryWithExplicit(
+                SqlServerEventId.ConflictingValueGenerationStrategiesWarning, WarningBehavior.Throw));
 
         ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(coreOptionsExtension);
     }

test/EFCore.InMemory.FunctionalTests/LoggingInMemoryTest.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.EntityFrameworkCore.InMemory.Diagnostics.Internal;
 using Microsoft.EntityFrameworkCore.InMemory.Infrastructure.Internal;
 
 namespace Microsoft.EntityFrameworkCore;
@@ -12,6 +13,9 @@ protected override DbContextOptionsBuilder CreateOptionsBuilder(IServiceCollecti
             .UseInMemoryDatabase("LoggingInMemoryTest")
             .UseInternalServiceProvider(services.AddEntityFrameworkInMemoryDatabase().BuildServiceProvider(validateScopes: true));
 
+    protected override TestLogger CreateTestLogger()
+        => new TestLogger<InMemoryLoggingDefinitions>();
+
     protected override string ProviderName
         => "Microsoft.EntityFrameworkCore.InMemory";
 

test/EFCore.InMemory.FunctionalTests/Query/WarningsTest.cs

@@ -10,9 +10,8 @@
 // ReSharper disable UnusedMember.Local
 // ReSharper disable InconsistentNaming
 namespace Microsoft.EntityFrameworkCore.Query;
-#pragma warning disable xUnit1000 // Test classes must be public
-internal class WarningsTest
-#pragma warning restore xUnit1000 // Test classes must be public
+
+public class WarningsTest
 {
     [ConditionalFact]
     public void Should_throw_by_default_when_transaction()

test/EFCore.Relational.Specification.Tests/LoggingRelationalTestBase.cs

@@ -3,6 +3,8 @@
 
 // ReSharper disable InconsistentNaming
 
+using Microsoft.EntityFrameworkCore.Diagnostics.Internal;
+
 namespace Microsoft.EntityFrameworkCore;
 
 public abstract class LoggingRelationalTestBase<TBuilder, TExtension> : LoggingTestBase
@@ -45,6 +47,106 @@ public void Logs_context_initialization_migrations_history_table_schema()
             ExpectedMessage("MigrationsHistoryTable=mySchema.MyHistory " + DefaultOptions),
             ActualMessage(s => CreateOptionsBuilder(s, b => b.MigrationsHistoryTable("MyHistory", "mySchema"))));
 
+    [ConditionalFact]
+    public virtual void IndexPropertiesBothMappedAndNotMappedToTable_throws_by_default()
+    {
+        using var context = new IndexPropertiesBothMappedAndNotMappedToTableContext(CreateOptionsBuilder(new ServiceCollection()));
+
+        Assert.Equal(
+            CoreStrings.WarningAsErrorTemplate(
+                RelationalEventId.IndexPropertiesBothMappedAndNotMappedToTable.ToString(),
+                RelationalResources.LogUnnamedIndexPropertiesBothMappedAndNotMappedToTable(CreateTestLogger())
+                    .GenerateMessage(nameof(Cat), "{'Name', 'Identity'}", nameof(Cat.Identity)),
+                "RelationalEventId.IndexPropertiesBothMappedAndNotMappedToTable"),
+            Assert.Throws<InvalidOperationException>(
+                () => context.Model).Message);
+    }
+
+    protected class IndexPropertiesBothMappedAndNotMappedToTableContext : DbContext
+    {
+        public IndexPropertiesBothMappedAndNotMappedToTableContext(DbContextOptionsBuilder optionsBuilder)
+            : base(optionsBuilder.Options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Animal>();
+            modelBuilder.Entity<Cat>().ToTable((string)null).HasIndex(nameof(Animal.Name), nameof(Cat.Identity));
+        }
+    }
+
+    [ConditionalFact]
+    public virtual void UnnamedIndexPropertiesMappedToNonOverlappingTables_throws_by_default()
+    {
+        using var context = new UnnamedIndexPropertiesMappedToNonOverlappingTablesContext(CreateOptionsBuilder(new ServiceCollection()));
+
+        Assert.Equal(
+            CoreStrings.WarningAsErrorTemplate(
+                RelationalEventId.IndexPropertiesMappedToNonOverlappingTables.ToString(),
+                RelationalResources.LogUnnamedIndexPropertiesMappedToNonOverlappingTables(CreateTestLogger())
+                    .GenerateMessage(
+                        nameof(Cat), "{'Name', 'Identity'}", nameof(Animal.Name), "{'Animals'}", nameof(Cat.Identity), "{'Cats'}"),
+                "RelationalEventId.IndexPropertiesMappedToNonOverlappingTables"),
+            Assert.Throws<InvalidOperationException>(
+                () => context.Model).Message);
+    }
+
+    protected class UnnamedIndexPropertiesMappedToNonOverlappingTablesContext : DbContext
+    {
+        public UnnamedIndexPropertiesMappedToNonOverlappingTablesContext(DbContextOptionsBuilder optionsBuilder)
+            : base(optionsBuilder.Options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Animal>().ToTable("Animals");
+            modelBuilder.Entity<Cat>().ToTable("Cats");
+            modelBuilder.Entity<Cat>().HasIndex(nameof(Animal.Name), nameof(Cat.Identity));
+        }
+    }
+
+    [ConditionalFact]
+    public virtual void ForeignKeyPropertiesMappedToUnrelatedTables_throws_by_default()
+    {
+        using var context = new ForeignKeyPropertiesMappedToUnrelatedTablesContext(CreateOptionsBuilder(new ServiceCollection()));
+
+        var definition = RelationalResources.LogForeignKeyPropertiesMappedToUnrelatedTables(CreateTestLogger());
+        Assert.Equal(
+            CoreStrings.WarningAsErrorTemplate(
+                RelationalEventId.ForeignKeyPropertiesMappedToUnrelatedTables.ToString(),
+                definition
+                    .GenerateMessage(
+                        l => l.Log(
+                            definition.Level,
+                            definition.EventId,
+                            definition.MessageFormat,
+                            "{'FavoritePersonId'}", nameof(Cat), nameof(Person), "{'FavoritePersonId'}", nameof(Cat), "{'Id'}",
+                            nameof(Person))),
+                "RelationalEventId.ForeignKeyPropertiesMappedToUnrelatedTables"),
+            Assert.Throws<InvalidOperationException>(
+                () => context.Model).Message);
+    }
+
+    protected class ForeignKeyPropertiesMappedToUnrelatedTablesContext : DbContext
+    {
+        public ForeignKeyPropertiesMappedToUnrelatedTablesContext(DbContextOptionsBuilder optionsBuilder)
+            : base(optionsBuilder.Options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Animal>()
+                .Ignore(a => a.FavoritePerson)
+                .Property<int>("FavoritePersonId");
+            modelBuilder.Entity<Cat>().ToTable("Cat")
+                .HasOne<Person>().WithMany()
+                .HasForeignKey("FavoritePersonId");
+        }
+    }
+
     protected abstract DbContextOptionsBuilder CreateOptionsBuilder(
         IServiceCollection services,
         Action<RelationalDbContextOptionsBuilder<TBuilder, TExtension>> relationalAction);

test/EFCore.Specification.Tests/LoggingTestBase.cs

@@ -32,6 +32,55 @@ protected virtual string ExpectedMessage(string optionsFragment)
             ProviderVersion,
             optionsFragment ?? "None").Trim();
 
+    [ConditionalFact]
+    public virtual void InvalidIncludePathError_throws_by_default()
+    {
+        using var context = new InvalidIncludePathErrorContext(CreateOptionsBuilder(new ServiceCollection()));
+
+        Assert.Equal(
+            CoreStrings.WarningAsErrorTemplate(
+                CoreEventId.InvalidIncludePathError.ToString(),
+                CoreResources.LogInvalidIncludePath(CreateTestLogger())
+                    .GenerateMessage("Wheels", "Wheels"),
+                "CoreEventId.InvalidIncludePathError"),
+            Assert.Throws<InvalidOperationException>(
+                () => context.Set<Animal>().Include("Wheels").Load()).Message);
+    }
+
+    protected class InvalidIncludePathErrorContext : DbContext
+    {
+        public InvalidIncludePathErrorContext(DbContextOptionsBuilder optionsBuilder)
+            : base(optionsBuilder.Options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+            => modelBuilder.Entity<Animal>();
+    }
+
+    protected class Animal
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public Person FavoritePerson { get; set; }
+    }
+
+    protected class Cat : Animal
+    {
+        public string Breed { get; set; }
+        public string Type { get; set; }
+        public int Identity { get; set; }
+    }
+
+    protected class Person
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string FavoriteBreed { get; set; }
+    }
+
+    protected abstract TestLogger CreateTestLogger();
+
     protected abstract DbContextOptionsBuilder CreateOptionsBuilder(IServiceCollection services);
 
     protected abstract string ProviderName { get; }

test/EFCore.SqlServer.FunctionalTests/LoggingSqlServerTest.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.EntityFrameworkCore.SqlServer.Diagnostics.Internal;
 using Microsoft.EntityFrameworkCore.SqlServer.Infrastructure.Internal;
 
 // ReSharper disable InconsistentNaming
@@ -15,6 +16,9 @@ protected override DbContextOptionsBuilder CreateOptionsBuilder(
             .UseInternalServiceProvider(services.AddEntityFrameworkSqlServer().BuildServiceProvider(validateScopes: true))
             .UseSqlServer("Data Source=LoggingSqlServerTest.db", relationalAction);
 
+    protected override TestLogger CreateTestLogger()
+        => new TestLogger<SqlServerLoggingDefinitions>();
+
     protected override string ProviderName
         => "Microsoft.EntityFrameworkCore.SqlServer";
 

test/EFCore.Sqlite.FunctionalTests/LoggingSqliteTest.cs

@@ -1,20 +1,55 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Transactions;
+using Microsoft.EntityFrameworkCore.Diagnostics.Internal;
+using Microsoft.EntityFrameworkCore.Sqlite.Diagnostics.Internal;
 using Microsoft.EntityFrameworkCore.Sqlite.Infrastructure.Internal;
 
 // ReSharper disable InconsistentNaming
 namespace Microsoft.EntityFrameworkCore;
 
 public class LoggingSqliteTest : LoggingRelationalTestBase<SqliteDbContextOptionsBuilder, SqliteOptionsExtension>
 {
+    [ConditionalFact]
+    public void AmbientTransactionWarning_throws_by_default()
+    {
+        using var context = new AmbientTransactionWarningContext(CreateOptionsBuilder(new ServiceCollection()));
+
+        context.Add(new Animal());
+
+        using var transactionScope = new TransactionScope();
+
+        Assert.Equal(
+            CoreStrings.WarningAsErrorTemplate(
+                RelationalEventId.AmbientTransactionWarning.ToString(),
+                RelationalResources.LogAmbientTransaction(CreateTestLogger()).GenerateMessage(),
+                "RelationalEventId.AmbientTransactionWarning"),
+            Assert.Throws<InvalidOperationException>(
+                () => context.SaveChanges()).Message);
+    }
+
+    protected class AmbientTransactionWarningContext : DbContext
+    {
+        public AmbientTransactionWarningContext(DbContextOptionsBuilder optionsBuilder)
+            : base(optionsBuilder.Options)
+        {
+        }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+            => modelBuilder.Entity<Animal>();
+    }
+
     protected override DbContextOptionsBuilder CreateOptionsBuilder(
         IServiceCollection services,
         Action<RelationalDbContextOptionsBuilder<SqliteDbContextOptionsBuilder, SqliteOptionsExtension>> relationalAction)
         => new DbContextOptionsBuilder()
             .UseInternalServiceProvider(services.AddEntityFrameworkSqlite().BuildServiceProvider(validateScopes: true))
             .UseSqlite("Data Source=LoggingSqliteTest.db", relationalAction);
 
+    protected override TestLogger CreateTestLogger()
+        => new TestLogger<SqliteLoggingDefinitions>();
+
     protected override string ProviderName
         => "Microsoft.EntityFrameworkCore.Sqlite";