public void ConnectionOrigin_should_return_user_code_when_existing_connection_and_compiled_model()
{
var contextInfo = new DbContextInfo(typeof(ContextWithExistingConnectionAndCompiledModel));
Assert.Equal(DbConnectionStringOrigin.UserCode, contextInfo.ConnectionStringOrigin);
Assert.Null(contextInfo.ConnectionStringName);
}
public void ConnectionOrigin_should_return_configuration_when_connection_string_configured()
{
var contextInfo = new DbContextInfo(typeof(ContextWithConfiguredConnectionString));
Assert.Equal(DbConnectionStringOrigin.Configuration, contextInfo.ConnectionStringOrigin);
Assert.Equal("ShortNameDbContext", contextInfo.ConnectionStringName);
}
public void ConnectionOrigin_should_return_by_convention_when_named_initialization()
{
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor));
Assert.Equal(DbConnectionStringOrigin.Convention, contextInfo.ConnectionStringOrigin);
Assert.Equal("foo", contextInfo.ConnectionStringName);
}
public void ConnectionOrigin_should_return_user_code_when_existing_object_context()
{
var contextInfo = new DbContextInfo(typeof(ContextWithExistingObjectContext));
Assert.Equal(DbConnectionStringOrigin.UserCode, contextInfo.ConnectionStringOrigin);
Assert.Null(contextInfo.ConnectionStringName);
}
public void ConnectionOrigin_should_return_by_convention_when_compiled_model()
{
var contextInfo = new DbContextInfo(typeof(ContextWithCompiledModel));
Assert.Equal(DbConnectionStringOrigin.Convention, contextInfo.ConnectionStringOrigin);
Assert.Equal(typeof(ContextWithCompiledModel).FullName, contextInfo.ConnectionStringName);
}
public void CreateInstance_should_return_valid_instance_when_context_constructible_via_factory()
{
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor));
Assert.True(contextInfo.IsConstructible);
Assert.Same(typeof(ContextWithoutDefaultCtor), contextInfo.CreateInstance().GetType());
}
public void CreateInstance_should_return_valid_instance_when_context_constructible()
{
var contextInfo = new DbContextInfo(typeof(SimpleContext));
Assert.True(contextInfo.IsConstructible);
Assert.Same(typeof(SimpleContext), contextInfo.CreateInstance().GetType());
}
public void ConnectionString_and_ConnectionName_should_return_values_when_context_constructible()
{
var contextInfo = new DbContextInfo(typeof(SimpleContext));
Assert.True(!string.IsNullOrWhiteSpace(contextInfo.ConnectionString));
Assert.Equal(typeof(SimpleContext).FullName, contextInfo.ConnectionStringName);
}
public void CreateInstance_should_return_null_when_context_not_constructible()
{
var contextInfo = new DbContextInfo(typeof(DbContext));
Assert.False(contextInfo.IsConstructible);
Assert.Null(contextInfo.CreateInstance());
}
internal static void MapContextToInfo(Type contextType, DbContextInfo info)
{
DebugCheck.NotNull(contextType);
DebugCheck.NotNull(info);
_infoMapping.AddOrUpdate(contextType, info, (t, i) => info);
}
public void ConnectionOrigin_should_return_user_code_when_connection_string_initialization()
{
var contextInfo = new DbContextInfo(typeof(ContextWithConnectionString));
Assert.Equal(DbConnectionStringOrigin.UserCode, contextInfo.ConnectionStringOrigin);
Assert.Null(contextInfo.ConnectionStringName);
}
public void ConnectionString_and_ConnectionName_should_return_nulls_when_context_not_constructible()
{
var contextInfo = new DbContextInfo(typeof(DbContext));
Assert.False(contextInfo.IsConstructible);
Assert.Null(contextInfo.ConnectionString);
Assert.Null(contextInfo.ConnectionStringName);
}
/// <summary>
/// For testing.
/// </summary>
internal DbMigrator(DbContext usersContext = null, DbProviderFactory providerFactory = null)
: base(null)
{
_contextForInterception = usersContext;
_providerFactory = providerFactory;
_usersContextInfo = new DbContextInfo(typeof(DbContext));
_configuration = new DbMigrationsConfiguration();
}
public void Can_use_custom_on_model_creating_action_to_configure_model_builder()
{
var contextInfo = new DbContextInfo(typeof(ContextWithExternalOnModelCreating2));
var objectContext = ((IObjectContextAdapter)contextInfo.CreateInstance()).ObjectContext;
Assert.NotNull(objectContext);
Assert.False(objectContext.CreateDatabaseScript().Contains("EdmMetadata"));
}
// TODO: [Fact(Skip = "SDE Merge - No partial trust yet")]
public void DbContextInfo_works_under_partial_trust()
{
var contextInfo = new DbContextInfo(typeof(AdvancedPatternsMasterContext),
ProviderRegistry.Sql2008_ProviderInfo);
var context = contextInfo.CreateInstance();
Assert.NotNull(context);
}
public void DbContextInfo_can_provide_a_database_first_model()
{
using (var context = new DbContextInfo(
typeof(DatabaseFirstContext),
AddConnectionStrings(CreateEmptyConfig())).CreateInstance())
{
// Will throw if DbFirstConnectionString is not found and used.
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
Assert.Equal("AdvancedPatternsModelFirstContext", objectContext.DefaultContainerName);
}
}
public void DbContextInfo_can_provide_a_code_first_model_without_hitting_the_database()
{
Database.SetInitializer<CodeFirstContext>(null);
using (var context = new DbContextInfo(
typeof(CodeFirstContext),
new DbProviderInfo("System.Data.SqlClient", "2008")).CreateInstance())
{
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
Assert.Equal("CodeFirstContext", objectContext.DefaultContainerName);
}
}
// <summary>
// For testing.
// </summary>
internal DbMigrator(
DbContext usersContext = null,
DbProviderFactory providerFactory = null,
MigrationAssembly migrationAssembly = null)
: base(null)
{
_usersContext = usersContext;
_providerFactory = providerFactory;
_migrationAssembly = migrationAssembly;
_usersContextInfo = new DbContextInfo(typeof(DbContext));
_configuration = new DbMigrationsConfiguration();
_calledByCreateDatabase = true;
}
public void CreateInstance_should_use_passed_connection_string_even_when_provider_info_is_passed_as_well()
{
var config = AddConnectionStrings(
CreateEmptyConfig().AddDefaultConnectionFactory(
typeof(FakeDbContextInfoConnectionFactory).FullName + ", EntityFramework.UnitTests",
new string[0]));
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor), config, ProviderRegistry.SqlCe4_ProviderInfo);
Assert.Equal(DbConnectionStringOrigin.Configuration, contextInfo.ConnectionStringOrigin);
Assert.Equal("Initial Catalog=foo", contextInfo.ConnectionString);
Assert.Equal("foo", contextInfo.ConnectionStringName);
}
public void CreateInstance_should_use_passed_provider_info_when_building_model()
{
var contextInfo = new DbContextInfo(typeof(SimpleContext), ProviderRegistry.SqlCe4_ProviderInfo);
Assert.Equal(ProviderRegistry.SqlCe4_ProviderInfo.ProviderInvariantName, contextInfo.ConnectionProviderName);
Assert.Equal(string.Empty, contextInfo.ConnectionString);
Database.SetInitializer <SimpleContext>(null);
var objectContext = ((IObjectContextAdapter)contextInfo.CreateInstance()).ObjectContext;
Assert.NotNull(objectContext);
Assert.Equal("SqlCeConnection", ((EntityConnection)objectContext.Connection).StoreConnection.GetType().Name);
}
public void Can_set_hard_coded_connection_from_default_config()
{
var connection = new DbConnectionInfo("OverrideConnectionTest");
var contextInfo = new DbContextInfo(typeof(SimpleContext), connection);
Assert.Equal(DbConnectionStringOrigin.DbContextInfo, contextInfo.ConnectionStringOrigin);
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
Assert.Equal("OverrideConnectionTest", contextInfo.ConnectionStringName);
Assert.True(contextInfo.IsConstructible);
using (var context = contextInfo.CreateInstance())
{
Assert.Equal("ConnectionFromAppConfig", context.Database.Connection.Database);
}
}
public void Supplied_config_used_to_load_original_and_overriden_connection()
{
var connection = new DbConnectionInfo("GetMeFromSuppliedConfig");
var contextInfo = new DbContextInfo(
typeof(ContextWithConnectionNameNotInAppConfigFile),
CreateEmptyConfig()
.AddConnectionString("GetMeFromSuppliedConfig", "Database=ConnectionFromSuppliedConfig", "System.Data.SqlClient")
.AddConnectionString("WontFindMeInDefaultConfig", "Database=WontFindMeInDefaultConfig", "System.Data.SqlClient"),
connection);
using (var context = contextInfo.CreateInstance())
{
Assert.Equal("ConnectionFromSuppliedConfig", context.Database.Connection.Database);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DbMigrator"/> class.
/// </summary>
/// <param name="configuration">Configuration to be used for the migration process.</param>
public DbMigrator(DbMigrationsConfiguration configuration)
: base(configuration)
{
_usersContextInfo = configuration.TargetDatabase == null ?
new DbContextInfo(configuration.ContextType) :
new DbContextInfo(configuration.ContextType, configuration.TargetDatabase);
if (_usersContextInfo.IsConstructible)
{
using (var context = _usersContextInfo.CreateInstance())
{
DbMigrationContext.Current.DatabaseName = context.Database.Connection.Database;
}
}
}
public void Can_set_hard_coded_connection()
{
var connection = new DbConnectionInfo("Database=UseThisDatabaseInstead", "System.Data.SqlClient");
var contextInfo = new DbContextInfo(typeof(SimpleContext), connection);
Assert.Equal(DbConnectionStringOrigin.DbContextInfo, contextInfo.ConnectionStringOrigin);
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
Assert.Equal(null, contextInfo.ConnectionStringName);
Assert.True(contextInfo.IsConstructible);
using (var context = contextInfo.CreateInstance())
{
Assert.Equal("UseThisDatabaseInstead", context.Database.Connection.Database);
}
}
public void Can_unset_custom_on_model_creating_action()
{
var contextInfo
= new DbContextInfo(
typeof(ContextWithExternalOnModelCreating3))
{
OnModelCreating = mb => mb.Ignore <FakeEntity>()
};
contextInfo.OnModelCreating = null;
var objectContext = ((IObjectContextAdapter)contextInfo.CreateInstance()).ObjectContext;
Assert.NotNull(objectContext);
Assert.True(objectContext.CreateDatabaseScript().Contains("FakeEntities"));
}
public void Should_select_connection_string_from_supplied_candidates()
{
var connectionStringSettings
= new ConnectionStringSettingsCollection
{
new ConnectionStringSettings("foo", "Initial Catalog=foo", "System.Data.SqlClient")
};
#pragma warning disable 618 // Obsolete ctor
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor), connectionStringSettings);
#pragma warning restore 618
Assert.Equal(DbConnectionStringOrigin.Configuration, contextInfo.ConnectionStringOrigin);
Assert.Equal("Initial Catalog=foo", contextInfo.ConnectionString);
Assert.Equal("foo", contextInfo.ConnectionStringName);
}
public void Should_use_use_default_DefaultConnectionFactory_if_supplied_config_contains_no_DefaultConnectionFactory()
{
RunTestWithConnectionFactory(
Database.ResetDefaultConnectionFactory,
() =>
{
var config = CreateEmptyConfig();
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor), config);
Assert.Equal(DbConnectionStringOrigin.Convention, contextInfo.ConnectionStringOrigin);
Assert.True(contextInfo.ConnectionString.Contains(@"Data Source=.\SQLEXPRESS"));
Assert.True(contextInfo.ConnectionString.Contains(@"Initial Catalog=foo"));
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
});
}
public void DbContextInfo_should_get_connection_info_from_given_existing_context()
{
var mockContext = new Mock <InternalContextForMock <SimpleContext> >();
mockContext.Setup(m => m.ConnectionStringOrigin).Returns(DbConnectionStringOrigin.UserCode);
mockContext.Setup(m => m.ProviderName).Returns("My.Provider");
mockContext.Setup(m => m.OriginalConnectionString).Returns("Databse=Foo");
mockContext.Setup(m => m.ConnectionStringName).Returns("SomeName");
var contextInfo = new DbContextInfo(mockContext.Object.Owner);
Assert.Equal(DbConnectionStringOrigin.UserCode, contextInfo.ConnectionStringOrigin);
Assert.Equal("Databse=Foo", contextInfo.ConnectionString);
Assert.Equal("SomeName", contextInfo.ConnectionStringName);
Assert.Equal("My.Provider", contextInfo.ConnectionProviderName);
}
public void DbContextInfo_can_provide_a_code_first_model_without_hitting_the_database_when_also_give_config()
{
Database.SetInitializer<CodeFirstScaffoldingContextWithConnection>(null);
using (var context = new DbContextInfo(
typeof(CodeFirstScaffoldingContextWithConnection),
AddConnectionStrings(CreateEmptyConfig()),
new DbProviderInfo("System.Data.SqlClient", "2008")).CreateInstance())
{
// Will throw if CodeFirstConnectionString is not found and will throw if it is used to
// make a connection since it points to a server that does not exist.
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
Assert.Equal("CodeFirstScaffoldingContextWithConnection", objectContext.DefaultContainerName);
Assert.Equal("Bar", ((CodeFirstScaffoldingContextWithConnection)context).ExtraInfo);
}
}
public void CreateInstance_should_use_passed_provider_info_when_building_model_even_when_config_is_passed_as_well()
{
var config = AddConnectionStrings(
CreateEmptyConfig().AddDefaultConnectionFactory(
typeof(FakeDbContextInfoConnectionFactory).FullName + ", EntityFramework.UnitTests",
new string[0]));
var contextInfo = new DbContextInfo(typeof(SimpleContext), config, ProviderRegistry.SqlCe4_ProviderInfo);
Assert.Equal(ProviderRegistry.SqlCe4_ProviderInfo.ProviderInvariantName, contextInfo.ConnectionProviderName);
Assert.Equal(string.Empty, contextInfo.ConnectionString);
Database.SetInitializer <SimpleContext>(null);
var objectContext = ((IObjectContextAdapter)contextInfo.CreateInstance()).ObjectContext;
Assert.NotNull(objectContext);
Assert.Equal("SqlCeConnection", ((EntityConnection)objectContext.Connection).StoreConnection.GetType().Name);
}
public void Should_obtain_DefaultConnectionFactory_from_supplied_config_but_this_can_be_overriden()
{
RunTestWithConnectionFactory(
Database.ResetDefaultConnectionFactory,
() =>
{
var config = CreateEmptyConfig().AddDefaultConnectionFactory(
typeof(FakeDbContextInfoConnectionFactory).FullName + ", EntityFramework.UnitTests",
new string[0]);
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor), config);
Assert.IsType <FakeDbContextInfoConnectionFactory>(FunctionalTestsConfiguration.OriginalConnectionFactories.Last());
Assert.Equal(DbConnectionStringOrigin.Convention, contextInfo.ConnectionStringOrigin);
Assert.Equal(@"Data Source=.\SQLEXPRESS;Initial Catalog=foo;Integrated Security=True", contextInfo.ConnectionString);
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
});
}
public void Can_set_hard_coded_connection_from_supplied_config()
{
var connection = new DbConnectionInfo("GetMeFromSuppliedConfig");
var contextInfo = new DbContextInfo(
typeof(SimpleContext),
CreateEmptyConfig().AddConnectionString(
"GetMeFromSuppliedConfig", "Database=ConnectionFromSuppliedConfig", "System.Data.SqlClient"),
connection);
Assert.Equal(DbConnectionStringOrigin.DbContextInfo, contextInfo.ConnectionStringOrigin);
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
Assert.Equal("GetMeFromSuppliedConfig", contextInfo.ConnectionStringName);
Assert.True(contextInfo.IsConstructible);
using (var context = contextInfo.CreateInstance())
{
Assert.Equal("ConnectionFromSuppliedConfig", context.Database.Connection.Database);
}
}
public void Should_use_connectioin_string_from_supplied_config_even_if_DefaultConnectionFactory_is_also_present()
{
RunTestWithConnectionFactory(
Database.ResetDefaultConnectionFactory,
() =>
{
var config =
AddConnectionStrings(
CreateEmptyConfig().AddDefaultConnectionFactory(
typeof(FakeDbContextInfoConnectionFactory).FullName + ", EntityFramework.UnitTests",
new string[0]));
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor), config);
Assert.Equal(DbConnectionStringOrigin.Configuration, contextInfo.ConnectionStringOrigin);
Assert.Equal("Initial Catalog=foo", contextInfo.ConnectionString);
Assert.Equal("foo", contextInfo.ConnectionStringName);
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
});
}
[Fact] // CodePlex 291, 1316
public void CreateInstance_should_not_cause_database_initializer_to_run_even_if_context_consturctor_would_cause_it()
{
var contextInfo = new DbContextInfo(typeof(InitTestContext));
using (var context = contextInfo.CreateInstance())
{
// Do something that would normally cause initialization
Assert.NotNull(((IObjectContextAdapter)context).ObjectContext);
}
Assert.False(InitTestInitializer.HasRun);
// Use context normally--initializer should now run.
using (var context = new InitTestContext())
{
Assert.NotNull(((IObjectContextAdapter)context).ObjectContext);
}
Assert.True(InitTestInitializer.HasRun);
}
public void Should_use_DefaultConnectionFactory_set_in_code_even_if_one_was_supplied_in_config()
{
#pragma warning disable 612,618
RunTestWithConnectionFactory(
() => Database.DefaultConnectionFactory = new SqlConnectionFactory(),
() =>
#pragma warning restore 612,618
{
var config = CreateEmptyConfig().
AddDefaultConnectionFactory(
typeof(FakeDbContextInfoConnectionFactory).FullName + ", EntityFramework.UnitTests",
new string[0]);
var contextInfo = new DbContextInfo(typeof(ContextWithoutDefaultCtor), config);
Assert.Equal(DbConnectionStringOrigin.Convention, contextInfo.ConnectionStringOrigin);
Assert.True(contextInfo.ConnectionString.Contains(@"Data Source=.\SQLEXPRESS"));
Assert.True(contextInfo.ConnectionString.Contains(@"Initial Catalog=foo"));
Assert.Equal("System.Data.SqlClient", contextInfo.ConnectionProviderName);
});
}
public void CreateInstance_should_attach_on_model_creating_custom_action_and_invoke_once()
{
var calledCount = 0;
var contextInfo = new DbContextInfo(typeof(ContextWithExternalOnModelCreating1));
contextInfo.OnModelCreating = _ => calledCount++;
contextInfo.CreateInstance();
Assert.Equal(0, calledCount);
var objectContext = ((IObjectContextAdapter)contextInfo.CreateInstance()).ObjectContext;
Assert.NotNull(objectContext);
Assert.Equal(1, calledCount);
objectContext = ((IObjectContextAdapter)contextInfo.CreateInstance()).ObjectContext;
Assert.NotNull(objectContext);
Assert.Equal(1, calledCount);
}
internal DbMigrator(DbMigrationsConfiguration configuration, DbContext usersContext)
: base(null)
{
Check.NotNull(configuration, "configuration");
Check.NotNull(configuration.ContextType, "configuration.ContextType");
_configuration = configuration;
_calledByCreateDatabase = usersContext != null;
// If DbContext CreateDatabase is using Migrations then the user has not opted out of initializers
// and if we disable the initializer here then future calls to Initialize the database (for this or
// a different connection) will fail. So only disable the initializer if Migrations are being used
// explicitly.
if (usersContext == null)
{
DisableInitializer(_configuration.ContextType);
}
if (_calledByCreateDatabase)
{
_usersContextInfo = new DbContextInfo(usersContext);
}
else
{
_usersContextInfo
= configuration.TargetDatabase == null
? new DbContextInfo(configuration.ContextType)
: new DbContextInfo(configuration.ContextType, configuration.TargetDatabase);
if (!_usersContextInfo.IsConstructible)
{
throw Error.ContextNotConstructible(configuration.ContextType);
}
}
_modelDiffer = _configuration.ModelDiffer;
var context = usersContext ?? _usersContextInfo.CreateInstance();
try
{
_migrationAssembly
= new MigrationAssembly(_configuration.MigrationsAssembly, _configuration.MigrationsNamespace);
_currentModel = context.GetModel();
var connection = context.Database.Connection;
_providerFactory = DbProviderServices.GetProviderFactory(connection);
var defaultSchema = context.InternalContext.DefaultSchema;
var historySchemas = GetHistorySchemas();
if (!string.IsNullOrWhiteSpace(defaultSchema))
{
historySchemas
= historySchemas.Concat(new[] { defaultSchema });
}
_historyRepository
= new HistoryRepository(
_usersContextInfo.ConnectionString,
_providerFactory,
_configuration.ContextKey,
historySchemas,
_migrationAssembly.MigrationIds.Any()
? _configuration.HistoryContextFactory
: null);
_providerManifestToken
= context.InternalContext.ModelProviderInfo != null
? context.InternalContext.ModelProviderInfo.ProviderManifestToken
: DbConfiguration
.GetService<IManifestTokenService>()
.GetProviderManifestToken(connection);
_targetDatabase
= Strings.LoggingTargetDatabaseFormat(
connection.DataSource,
connection.Database,
_usersContextInfo.ConnectionProviderName,
_usersContextInfo.ConnectionStringOrigin == DbConnectionStringOrigin.DbContextInfo
? Strings.LoggingExplicit
: _usersContextInfo.ConnectionStringOrigin.ToString());
_legacyContextKey = context.InternalContext.ContextKey;
_currentHistoryModel = GetCurrentHistoryModel(defaultSchema);
_initialHistoryModel = GetInitialHistoryModel();
_emptyModel = GetEmptyModel();
AttachHistoryModel(_currentModel);
}
finally
{
if (usersContext == null)
{
context.Dispose();
}
}
}
internal DbMigrator(DbMigrationsConfiguration configuration, DbContext usersContext, DatabaseExistenceState existenceState, bool calledByCreateDatabase)
: base(null)
{
Check.NotNull(configuration, "configuration");
Check.NotNull(configuration.ContextType, "configuration.ContextType");
_configuration = configuration;
_calledByCreateDatabase = calledByCreateDatabase;
_existenceState = existenceState;
if (usersContext != null)
{
_usersContextInfo = new DbContextInfo(usersContext);
}
else
{
_usersContextInfo
= configuration.TargetDatabase == null
? new DbContextInfo(configuration.ContextType)
: new DbContextInfo(configuration.ContextType, configuration.TargetDatabase);
if (!_usersContextInfo.IsConstructible)
{
throw Error.ContextNotConstructible(configuration.ContextType);
}
}
_modelDiffer = _configuration.ModelDiffer;
var context = usersContext ?? _usersContextInfo.CreateInstance();
_usersContext = context;
try
{
_migrationAssembly
= new MigrationAssembly(
_configuration.MigrationsAssembly,
_configuration.MigrationsNamespace);
_currentModel = context.GetModel();
_connection = context.Database.Connection;
_providerFactory = DbProviderServices.GetProviderFactory(_connection);
_defaultSchema
= context.InternalContext.DefaultSchema
?? EdmModelExtensions.DefaultSchema;
_historyContextFactory
= _configuration
.GetHistoryContextFactory(_usersContextInfo.ConnectionProviderName);
_historyRepository
= new HistoryRepository(
context.InternalContext,
_usersContextInfo.ConnectionString,
_providerFactory,
_configuration.ContextKey,
_configuration.CommandTimeout,
_historyContextFactory,
schemas: new[] { _defaultSchema }.Concat(GetHistorySchemas()),
contextForInterception: _usersContext,
initialExistence: _existenceState);
_providerManifestToken
= context.InternalContext.ModelProviderInfo != null
? context.InternalContext.ModelProviderInfo.ProviderManifestToken
: DbConfiguration
.DependencyResolver
.GetService<IManifestTokenResolver>()
.ResolveManifestToken(_connection);
var modelBuilder
= context.InternalContext.CodeFirstModel.CachedModelBuilder;
_modificationCommandTreeGenerator
= new Lazy<ModificationCommandTreeGenerator>(
() =>
new ModificationCommandTreeGenerator(
modelBuilder.BuildDynamicUpdateModel(
new DbProviderInfo(
_usersContextInfo.ConnectionProviderName,
_providerManifestToken)),
CreateConnection()));
var interceptionContext = new DbInterceptionContext();
interceptionContext = interceptionContext.WithDbContext(_usersContext);
_targetDatabase
= Strings.LoggingTargetDatabaseFormat(
DbInterception.Dispatch.Connection.GetDataSource(_connection, interceptionContext),
DbInterception.Dispatch.Connection.GetDatabase(_connection, interceptionContext),
_usersContextInfo.ConnectionProviderName,
_usersContextInfo.ConnectionStringOrigin == DbConnectionStringOrigin.DbContextInfo
? Strings.LoggingExplicit
: _usersContextInfo.ConnectionStringOrigin.ToString());
_legacyContextKey = context.InternalContext.DefaultContextKey;
_emptyModel = GetEmptyModel();
}
finally
{
if (usersContext == null)
{
_usersContext = null;
context.Dispose();
}
}
}
internal static void MapContextToInfo(Type contextType, DbContextInfo info)
{
DebugCheck.NotNull(contextType);
DebugCheck.NotNull(info);
_infoMapping.AddOrUpdate(contextType, info, (t, i) => info);
}
public void EdmxWriter_can_write_an_EDMX_when_DbContextInfo_is_used_to_specify_the_provider_info()
{
var contextInfo = new DbContextInfo(
typeof(SimpleModelContext),
new DbProviderInfo("System.Data.SqlClient", "2008"));
using (var context = contextInfo.CreateInstance())
{
var edmxBuilder = new StringBuilder();
EdmxWriter.WriteEdmx(context, XmlWriter.Create(edmxBuilder));
SanityCheckEdmx(edmxBuilder);
}
}
internal DbMigrator(DbMigrationsConfiguration configuration, DbContext usersContext)
: base(null)
{
Contract.Requires(configuration != null);
Contract.Requires(configuration.ContextType != null);
_configuration = configuration;
_calledByCreateDatabase = usersContext != null;
// If DbContext CreateDatabase is using Migrations then the user has not opted out of initializers
// and if we disable the initializer here then future calls to Initialize the database (for this or
// a different connection) will fail. So only disable the initializer if Migrations are being used
// explicitly.
if (usersContext == null)
{
DisableInitializer(_configuration.ContextType);
}
if (_calledByCreateDatabase)
{
_usersContextInfo = new DbContextInfo(usersContext);
}
else
{
_usersContextInfo
= configuration.TargetDatabase == null
? new DbContextInfo(configuration.ContextType)
: new DbContextInfo(configuration.ContextType, configuration.TargetDatabase);
if (!_usersContextInfo.IsConstructible)
{
throw Error.ContextNotConstructible(configuration.ContextType);
}
}
_modelDiffer = _configuration.ModelDiffer;
var context = usersContext ?? _usersContextInfo.CreateInstance();
try
{
_migrationAssembly
= new MigrationAssembly(_configuration.MigrationsAssembly, _configuration.MigrationsNamespace);
_currentModel = context.GetModel();
var connection = context.Database.Connection;
_providerFactory = DbProviderServices.GetProviderFactory(connection);
_defaultSchema = context.InternalContext.DefaultSchema;
var historySchemas = GetHistorySchemas();
if (!string.IsNullOrWhiteSpace(_defaultSchema))
{
historySchemas = historySchemas.Concat(new[] { _defaultSchema });
}
_historyRepository
= new HistoryRepository(_usersContextInfo.ConnectionString, _providerFactory, historySchemas);
_providerManifestToken
= context.InternalContext.ModelProviderInfo != null
? context.InternalContext.ModelProviderInfo.ProviderManifestToken
: DbProviderServices.GetProviderServices(connection).
GetProviderManifestTokenChecked(connection);
_targetDatabase
= Strings.LoggingTargetDatabaseFormat(
connection.DataSource,
connection.Database,
_usersContextInfo.ConnectionProviderName,
_usersContextInfo.ConnectionStringOrigin == DbConnectionStringOrigin.DbContextInfo
? Strings.LoggingExplicit
: _usersContextInfo.ConnectionStringOrigin.ToString());
}
finally
{
if (usersContext == null)
{
context.Dispose();
}
}
var providerInfo
= new DbProviderInfo(_usersContextInfo.ConnectionProviderName, _providerManifestToken);
_emptyModel = new Lazy<XDocument>(() => new DbModelBuilder().Build(providerInfo).GetModel());
_historyRepository.AppendHistoryModel(_currentModel, providerInfo);
}
public void ContextType_should_return_tyoe_of_passed_context_instance()
{
var contextInfo = new DbContextInfo(new SimpleContext());
Assert.Same(typeof(SimpleContext), contextInfo.ContextType);
}
internal DbMigrator(DbMigrationsConfiguration configuration, DbContext usersContext)
: base(null)
{
Check.NotNull(configuration, "configuration");
Check.NotNull(configuration.ContextType, "configuration.ContextType");
_configuration = configuration;
_calledByCreateDatabase = usersContext != null;
// If DbContext CreateDatabase is using Migrations then the user has not opted out of initializers
// and if we disable the initializer here then future calls to Initialize the database (for this or
// a different connection) will fail. So only disable the initializer if Migrations are being used
// explicitly.
if (usersContext == null)
{
DisableInitializer(_configuration.ContextType);
}
if (_calledByCreateDatabase)
{
_usersContextInfo = new DbContextInfo(usersContext);
}
else
{
_usersContextInfo
= configuration.TargetDatabase == null
? new DbContextInfo(configuration.ContextType)
: new DbContextInfo(configuration.ContextType, configuration.TargetDatabase);
if (!_usersContextInfo.IsConstructible)
{
throw Error.ContextNotConstructible(configuration.ContextType);
}
}
_modelDiffer = _configuration.ModelDiffer;
var context = usersContext ?? _usersContextInfo.CreateInstance();
_contextForInterception = context;
try
{
_migrationAssembly
= new MigrationAssembly(
_configuration.MigrationsAssembly,
_configuration.MigrationsNamespace);
_currentModel = context.GetModel();
var connection = context.Database.Connection;
_providerFactory = DbProviderServices.GetProviderFactory(connection);
_defaultSchema
= context.InternalContext.DefaultSchema
?? EdmModelExtensions.DefaultSchema;
_historyRepository
= new HistoryRepository(
_usersContextInfo.ConnectionString,
_providerFactory,
_configuration.ContextKey,
_configuration.CommandTimeout,
new[] { _defaultSchema }.Concat(GetHistorySchemas()),
_configuration.HistoryContextFactory);
_providerManifestToken
= context.InternalContext.ModelProviderInfo != null
? context.InternalContext.ModelProviderInfo.ProviderManifestToken
: DbConfiguration
.GetService<IManifestTokenService>()
.GetProviderManifestToken(connection);
_modificationCommandTreeGenerator
= new ModificationCommandTreeGenerator(
context.GetDynamicUpdateModel(
new DbProviderInfo(
_usersContextInfo.ConnectionProviderName,
_providerManifestToken)),
CreateConnection());
_targetDatabase
= Strings.LoggingTargetDatabaseFormat(
connection.DataSource,
connection.Database,
_usersContextInfo.ConnectionProviderName,
_usersContextInfo.ConnectionStringOrigin == DbConnectionStringOrigin.DbContextInfo
? Strings.LoggingExplicit
: _usersContextInfo.ConnectionStringOrigin.ToString());
_legacyContextKey = context.InternalContext.ContextKey;
_emptyModel = GetEmptyModel();
}
finally
{
if (usersContext == null)
{
_contextForInterception = null;
context.Dispose();
}
}
}