private void Can_replace_connection_implementation(
            ReplaceConnectionContext context,
            LazyInternalConnection newConnection)
        {
            Database.Delete(newConnection.Connection);
            Database.Delete(typeof(ReplaceConnectionContext).DatabaseName());

            context.InternalContext.OverrideConnection(newConnection);

            context.Entities.Add(
                new PersistEntity
                {
                    Name = "Testing"
                });
            context.SaveChanges();

            Assert.Same(newConnection.Connection, context.Database.Connection);
            Assert.True(Database.Exists(newConnection.Connection));
            Assert.False(Database.Exists(typeof(ReplaceConnectionContext).DatabaseName()));

            // By pass EF just to make sure everything targetted the correct database
            var cmd = newConnection.Connection.CreateCommand();
            cmd.CommandText = "SELECT Count(*) FROM PersistEntities";
            cmd.Connection.Open();
            Assert.Equal(1, cmd.ExecuteScalar());
            cmd.Connection.Close();
        }

        public void Name_of_context_with_namespace_stripped_is_found_in_app_config()
        {
            using (var internalConnection = new LazyInternalConnection("Couger35.Hubcap.ShortNameDbContext"))
            {
                var connection = internalConnection.Connection;

                Assert.Equal("ShortNameInAppConfig", connection.Database);
                Assert.IsType<SqlConnection>(connection);
            }
        }

        public void Full_name_of_context_is_found_in_app_config()
        {
            using (var internalConnection = new LazyInternalConnection("Couger35.Hubcap.FullNameDbContext"))
            {
                var connection = internalConnection.Connection;

                Assert.Equal("FullNameInAppConfig", connection.Database);
                Assert.IsType<SqlConnection>(connection);
            }
        }

        public void Name_of_context_with_DbContext_stripped_is_not_found_in_app_config()
        {
            using (var internalConnection = new LazyInternalConnection("Couger35.Hubcap.FullNameDbStrippedDbContext"))
            {
                var connection = internalConnection.Connection;

                Assert.Equal("Couger35.Hubcap.FullNameDbStrippedDbContext", connection.Database);
                Assert.IsType<SqlConnection>(connection);
            }
        }

 public void Can_replace_connection()
 {
     using (var context = new ReplaceConnectionContext())
     {
         using (var newConnection = new LazyInternalConnection(
             context,
             new DbConnectionInfo(
                 SimpleConnectionString("NewReplaceConnectionContextDatabase"),
                 "System.Data.SqlClient")))
         {
             Can_replace_connection_implementation(context, newConnection);
         }
     }
 }

 public void Can_replace_connection_with_different_provider()
 {
     using (var context = new ReplaceConnectionContext())
     {
         using (var newConnection = new LazyInternalConnection(
             context,
             new DbConnectionInfo(
                 "Data Source=NewReplaceConnectionContextDatabase.sdf",
                 "System.Data.SqlServerCe.4.0")))
         {
             Can_replace_connection_implementation(context, newConnection);
         }
     }
 }

        public void LazyInternalConnection_can_calculate_ConnectionHasModel_true_from_connection_string_without_initializing()
        {
            var efString = ConfigurationManager.ConnectionStrings["EntityConnectionString"].ConnectionString;

            using (var connection = new LazyInternalConnection(efString))
            {
                Assert.True(connection.ConnectionHasModel);
                Assert.False(connection.IsInitialized);
            }
        }

 public void LazyInternalConnection_can_calculate_ConnectionHasModel_true_from_config_file_without_initializing()
 {
     using (var connection = new LazyInternalConnection("name=EntityConnectionString"))
     {
         Assert.True(connection.ConnectionHasModel);
         Assert.False(connection.IsInitialized);
     }
 }

 public void LazyInternalConnection_can_calculate_ConnectionHasModel_false_from_convention_without_initializing()
 {
     using (var connection = new LazyInternalConnection("MyName"))
     {
         Assert.False(connection.ConnectionHasModel);
         Assert.False(connection.IsInitialized);
     }
 }

        public void LazyInternalConnection_can_create_connection_from_DbConnectionInfo_from_overridden_config_file()
        {
            using (var connection = new LazyInternalConnection(new DbConnectionInfo("LazyConnectionTest")))
            {
                connection.AppConfig =
                    new AppConfig(
                        CreateEmptyConfig().AddConnectionString(
                            "LazyConnectionTest", "Database=FromOverridenConfig", "System.Data.SqlClient"));

                Assert.IsType<SqlConnection>(connection.Connection);
                Assert.Equal("FromOverridenConfig", connection.Connection.Database);
                Assert.Equal("LazyConnectionTest", connection.ConnectionStringName);
                Assert.Equal(DbConnectionStringOrigin.DbContextInfo, connection.ConnectionStringOrigin);
            }
        }

        public void Connection_from_factory_is_cached()
        {
            using (var internalConnection = new LazyInternalConnection("NameForFactory"))
            {
                var connection = internalConnection.Connection;

                Assert.Same(connection, internalConnection.Connection);
                Assert.Same(connection, internalConnection.Connection);
            }
        }

 public void LazyInternalConnection_provider_name_calculated_when_connection_by_convention()
 {
     using (var connection = new LazyInternalConnection("ConnectionName"))
     {
         Assert.Equal("System.Data.SqlClient", connection.ProviderName);
     }
 }

        public void LazyInternalConnection_can_calculate_ConnectionHasModel_true_after_initializing()
        {
            using (var connection = new LazyInternalConnection("name=EntityConnectionString"))
            {
                var x = connection.Connection;
                Assert.True(connection.IsInitialized);

                Assert.True(connection.ConnectionHasModel);
            }
        }

        public void Explicit_name_is_used_without_stripping_DbContext()
        {
            using (var internalConnection = new LazyInternalConnection("Couger35.Hubcap.NameForFactoryDbContext"))
            {
                var connection = internalConnection.Connection;

                Assert.Equal("Couger35.Hubcap.NameForFactoryDbContext", connection.Database);
                Assert.IsType<SqlConnection>(connection);
            }
        }

        public void Disposed_LazyInternalConnection_can_be_reused()
        {
            var internalConnection = new LazyInternalConnection("NameForFactory");
            try
            {
                var disposed1 = 0;
                var disposed2 = 0;

                var connection1 = internalConnection.Connection;
                connection1.Disposed += (_, __) => disposed1++;

                internalConnection.Dispose();
                Assert.Equal(1, disposed1);
                Assert.Equal(0, disposed2);

                var connection2 = internalConnection.Connection;
                connection2.Disposed += (_, __) => disposed2++;

                internalConnection.Dispose();
                Assert.Equal(1, disposed1);
                Assert.Equal(1, disposed2);
            }
            finally
            {
                internalConnection.Dispose();
            }
        }

 public void Connection_created_from_factory_is_disposed_after_use()
 {
     var disposed = false;
     using (var internalConnection = new LazyInternalConnection("NameForFactory"))
     {
         var connection = internalConnection.Connection;
         connection.Disposed += (_, __) => disposed = true;
     }
     Assert.True(disposed);
 }

 public void Connection_created_from_hard_coded_connection_string_is_disposed_after_use()
 {
     var disposed = false;
     using (var internalConnection = new LazyInternalConnection("Database=HardCodedConnectionString"))
     {
         var connection = internalConnection.Connection;
         connection.Disposed += (_, __) => disposed = true;
     }
     Assert.True(disposed);
 }

 public void Connection_created_from_app_config_is_disposed_after_use()
 {
     var disposed = false;
     using (var internalConnection = new LazyInternalConnection("Couger35.Hubcap.FullNameDbContext"))
     {
         var connection = internalConnection.Connection;
         connection.Disposed += (_, __) => disposed = true;
     }
     Assert.True(disposed);
 }

 public void Changed_default_connection_factory_that_results_in_null_connections_throws()
 {
     var existingFactory = DefaultConnectionFactoryResolver.Instance.ConnectionFactory;
     try
     {
         DefaultConnectionFactoryResolver.Instance.ConnectionFactory = new Mock<IDbConnectionFactory>().Object;
         using (var internalConnection = new LazyInternalConnection("NameNotInAppConfig"))
         {
             Assert.Equal(
                 Strings.DbContext_ConnectionFactoryReturnedNullConnection,
                 Assert.Throws<InvalidOperationException>(() => { var _ = internalConnection.Connection; }).Message);
         }
     }
     finally
     {
         DefaultConnectionFactoryResolver.Instance.ConnectionFactory = existingFactory;
     }
 }

        public void LazyInternalConnection_can_calculate_ConnectionHasModel_false_after_initializing()
        {
            using (var connection = new LazyInternalConnection("name=LazyConnectionTest"))
            {
                var x = connection.Connection;
                Assert.True(connection.IsInitialized);

                Assert.False(connection.ConnectionHasModel);
            }
        }