Merge ExistingConnectionTest with ConnectionSpecificationTest

src/EFCore.Relational/Infrastructure/RelationalModelValidator.cs

@@ -334,24 +334,19 @@ protected virtual void ValidateSharedTableCompatibility(
                     continue;
                 }
 
-                if (mappedType.FindPrimaryKey() != null
-                    && mappedType.FindForeignKeys(mappedType.FindPrimaryKey().Properties)
-                        .Any(
-                            fk => fk.PrincipalKey.IsPrimaryKey()
-                                && unvalidatedTypes.Contains(fk.PrincipalEntityType)))
+                var primaryKey = mappedType.FindPrimaryKey();
+                if (primaryKey != null
+                    && (mappedType.FindForeignKeys(primaryKey.Properties)
+                        .FirstOrDefault(fk => fk.PrincipalKey.IsPrimaryKey()
+                                && unvalidatedTypes.Contains(fk.PrincipalEntityType)) is IForeignKey linkingFK))
                 {
                     if (mappedType.BaseType != null)
                     {
-                        var principalType = mappedType.FindForeignKeys(mappedType.FindPrimaryKey().Properties)
-                            .First(
-                                fk => fk.PrincipalKey.IsPrimaryKey()
-                                    && unvalidatedTypes.Contains(fk.PrincipalEntityType))
-                            .PrincipalEntityType;
                         throw new InvalidOperationException(
                             RelationalStrings.IncompatibleTableDerivedRelationship(
                                 storeObject.DisplayName(),
                                 mappedType.DisplayName(),
-                                principalType.DisplayName()));
+                                linkingFK.PrincipalEntityType.DisplayName()));
                     }
 
                     continue;
@@ -388,18 +383,21 @@ protected virtual void ValidateSharedTableCompatibility(
 
                 foreach (var nextEntityType in directlyConnectedTypes)
                 {
-                    var otherKey = nextEntityType.FindPrimaryKey();
-                    if (key?.GetName(storeObject) != otherKey?.GetName(storeObject))
+                    if (key != null)
                     {
-                        throw new InvalidOperationException(
-                            RelationalStrings.IncompatibleTableKeyNameMismatch(
-                                storeObject.DisplayName(),
-                                entityType.DisplayName(),
-                                nextEntityType.DisplayName(),
-                                key?.GetName(storeObject),
-                                key?.Properties.Format(),
-                                otherKey?.GetName(storeObject),
-                                otherKey?.Properties.Format()));
+                        var otherKey = nextEntityType.FindPrimaryKey();
+                        if (key.GetName(storeObject) != otherKey.GetName(storeObject))
+                        {
+                            throw new InvalidOperationException(
+                                RelationalStrings.IncompatibleTableKeyNameMismatch(
+                                    storeObject.DisplayName(),
+                                    entityType.DisplayName(),
+                                    nextEntityType.DisplayName(),
+                                    key.GetName(storeObject),
+                                    key.Properties.Format(),
+                                    otherKey.GetName(storeObject),
+                                    otherKey.Properties.Format()));
+                        }
                     }
 
                     var nextComment = nextEntityType.GetComment();
@@ -599,8 +597,7 @@ protected virtual void ValidateSharedViewCompatibility(
 
         private static bool IsIdentifyingPrincipal(IEntityType dependentEntityType, IEntityType principalEntityType)
             => dependentEntityType.FindForeignKeys(dependentEntityType.FindPrimaryKey().Properties)
-                .Any(
-                    fk => fk.PrincipalKey.IsPrimaryKey()
+                .Any(fk => fk.PrincipalKey.IsPrimaryKey()
                         && fk.PrincipalEntityType == principalEntityType);
 
         /// <summary>

src/EFCore/ChangeTrackingStrategy.cs

@@ -30,14 +30,12 @@ public enum ChangeTrackingStrategy
         ///     <para>
         ///         To use this strategy, the entity class must implement <see cref="INotifyPropertyChanged" /> and
         ///         <see cref="INotifyPropertyChanging" />.
-        ///         Original values are recorded when the entity raises the <see cref="INotifyPropertyChanging.PropertyChanging" /> event. Properties
-        ///         are
-        ///         marked as modified when the entity raises the <see cref="INotifyPropertyChanged.PropertyChanged" /> event.
+        ///         Original values are recorded when the entity raises the <see cref="INotifyPropertyChanging.PropertyChanging" /> event.
+        ///         Properties are marked as modified when the entity raises the <see cref="INotifyPropertyChanged.PropertyChanged" /> event.
         ///     </para>
         ///     <para>
-        ///         Original values are only recorded when they are required to save changes to the entity. For example, properties that are configured
-        ///         as
-        ///         concurrency tokens.
+        ///         Original values are only recorded when they are required to save changes to the entity. For example, properties that are
+        ///         configured as concurrency tokens.
         ///     </para>
         /// </summary>
         ChangingAndChangedNotifications,
@@ -46,8 +44,8 @@ public enum ChangeTrackingStrategy
         ///     <para>
         ///         To use this strategy, the entity class must implement <see cref="INotifyPropertyChanged" /> and
         ///         <see cref="INotifyPropertyChanging" />.
-        ///         Original values are recorded when the entity raises the <see cref="INotifyPropertyChanging.PropertyChanging" />. Properties are
-        ///         marked as modified when the entity raises the <see cref="INotifyPropertyChanged.PropertyChanged" /> event.
+        ///         Original values are recorded when the entity raises the <see cref="INotifyPropertyChanging.PropertyChanging" />.
+        ///         Properties are marked as modified when the entity raises the <see cref="INotifyPropertyChanged.PropertyChanged" /> event.
         ///     </para>
         ///     <para>
         ///         Original values are recorded for all properties, regardless of whether they are required to save changes to the entity.

src/EFCore/Metadata/Conventions/ForeignKeyPropertyDiscoveryConvention.cs

@@ -38,21 +38,21 @@ namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
     ///     </para>
     /// </summary>
     public class ForeignKeyPropertyDiscoveryConvention :
-        IForeignKeyAddedConvention,
-        INavigationAddedConvention,
-        IPropertyAddedConvention,
         IEntityTypeMemberIgnoredConvention,
-        IPropertyNullabilityChangedConvention,
-        IPropertyFieldChangedConvention,
+        IEntityTypePrimaryKeyChangedConvention,
+        IForeignKeyAddedConvention,
         IForeignKeyPropertiesChangedConvention,
         IForeignKeyPrincipalEndChangedConvention,
         IForeignKeyUniquenessChangedConvention,
         IForeignKeyRequirednessChangedConvention,
-        ISkipNavigationForeignKeyChangedConvention,
-        ISkipNavigationInverseChangedConvention,
         IKeyAddedConvention,
         IKeyRemovedConvention,
-        IEntityTypePrimaryKeyChangedConvention,
+        INavigationAddedConvention,
+        ISkipNavigationForeignKeyChangedConvention,
+        ISkipNavigationInverseChangedConvention,
+        IPropertyAddedConvention,
+        IPropertyNullabilityChangedConvention,
+        IPropertyFieldChangedConvention,
         IModelFinalizingConvention
     {
         /// <summary>

src/EFCore/Metadata/Conventions/RelationshipDiscoveryConvention.cs

@@ -24,8 +24,8 @@ public class RelationshipDiscoveryConvention :
         IEntityTypeAddedConvention,
         IEntityTypeIgnoredConvention,
         IEntityTypeBaseTypeChangedConvention,
-        INavigationRemovedConvention,
         IEntityTypeMemberIgnoredConvention,
+        INavigationRemovedConvention,
         INavigationAddedConvention,
         IForeignKeyOwnershipChangedConvention
     {

test/EFCore.SqlServer.FunctionalTests/ConnectionSpecificationTest.cs

@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Data.SqlClient;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.TestUtilities;
@@ -450,5 +452,90 @@ private class Customer
             public string Fax { get; set; }
             // ReSharper restore UnusedMember.Local
         }
+
+        [ConditionalTheory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task Can_use_an_existing_closed_connection_test(bool openConnection)
+        {
+            var serviceProvider = new ServiceCollection()
+                .AddEntityFrameworkSqlServer()
+                .BuildServiceProvider();
+
+            using var store = SqlServerTestStore.GetNorthwindStore();
+            store.CloseConnection();
+
+            var openCount = 0;
+            var closeCount = 0;
+            var disposeCount = 0;
+
+            using var connection = new SqlConnection(store.ConnectionString);
+            if (openConnection)
+            {
+                await connection.OpenAsync();
+            }
+
+            connection.StateChange += (_, a) =>
+            {
+                switch (a.CurrentState)
+                {
+                    case ConnectionState.Open:
+                        openCount++;
+                        break;
+                    case ConnectionState.Closed:
+                        closeCount++;
+                        break;
+                }
+            };
+            connection.Disposed += (_, __) => disposeCount++;
+
+            using (var context = new NorthwindContext(serviceProvider, connection))
+            {
+                Assert.Equal(91, await context.Customers.CountAsync());
+            }
+
+            if (openConnection)
+            {
+                Assert.Equal(ConnectionState.Open, connection.State);
+                Assert.Equal(0, openCount);
+                Assert.Equal(0, closeCount);
+            }
+            else
+            {
+                Assert.Equal(ConnectionState.Closed, connection.State);
+                Assert.Equal(1, openCount);
+                Assert.Equal(1, closeCount);
+            }
+
+            Assert.Equal(0, disposeCount);
+        }
+
+        private class NorthwindContext : DbContext
+        {
+            private readonly IServiceProvider _serviceProvider;
+            private readonly SqlConnection _connection;
+
+            public NorthwindContext(IServiceProvider serviceProvider, SqlConnection connection)
+            {
+                _serviceProvider = serviceProvider;
+                _connection = connection;
+            }
+
+            // ReSharper disable once UnusedAutoPropertyAccessor.Local
+            public DbSet<Customer> Customers { get; set; }
+
+            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+                => optionsBuilder
+                    .UseSqlServer(_connection, b => b.ApplyConfiguration())
+                    .UseInternalServiceProvider(_serviceProvider);
+
+            protected override void OnModelCreating(ModelBuilder modelBuilder)
+                => modelBuilder.Entity<Customer>(
+                    b =>
+                    {
+                        b.HasKey(c => c.CustomerID);
+                        b.ToTable("Customers");
+                    });
+        }
     }
 }