public virtual void BootstrapUsingEFProviderDdl(VersionedModel versionedModel)
{
DbConnection connection = (DbConnection)null;
try
{
connection = this.CreateConnection();
using (HistoryContext context = this.CreateContext(connection, (string)null))
{
context.Database.ExecuteSqlCommand(((IObjectContextAdapter)context).ObjectContext.CreateDatabaseScript());
context.History.Add(new HistoryRow()
{
MigrationId = MigrationAssembly.CreateMigrationId(Strings.InitialCreate).RestrictTo(this._migrationIdMaxLength),
ContextKey = this._contextKey,
Model = new ModelCompressor().Compress(versionedModel.Model),
ProductVersion = versionedModel.Version ?? HistoryRepository._productVersion
});
context.SaveChanges();
}
}
finally
{
this.DisposeConnection(connection);
}
}
public void GetPendingMigrations_should_return_migrations_based_on_context_key()
{
ResetDatabase();
var historyRepository1 = new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey1", null, HistoryContext.DefaultFactory);
var historyRepository2 = new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey2", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", model),
historyRepository2.CreateInsertOperation("Migration 1", model),
historyRepository1.CreateInsertOperation("Migration 3", model),
historyRepository1.CreateInsertOperation("Migration 5", model));
}
var pendingMigrations =
historyRepository1.GetPendingMigrations(
new[] { "Migration 1", "Migration 2", "Migration 3", "Migration 4", "Migration 5" });
Assert.Equal("Migration 2", pendingMigrations.First());
Assert.Equal("Migration 4", pendingMigrations.Last());
}
public virtual bool CompatibleWithModel(
InternalContext internalContext,
ModelHashCalculator modelHashCalculator,
bool throwIfNoMetadata,
DatabaseExistenceState existenceState = DatabaseExistenceState.Unknown)
{
if (internalContext.CodeFirstModel == null)
{
if (throwIfNoMetadata)
{
throw Error.Database_NonCodeFirstCompatibilityCheck();
}
return(true);
}
VersionedModel model = internalContext.QueryForModel(existenceState);
if (model != null)
{
return(internalContext.ModelMatches(model));
}
string a = internalContext.QueryForModelHash();
if (a != null)
{
return(string.Equals(a, modelHashCalculator.Calculate(internalContext.CodeFirstModel), StringComparison.Ordinal));
}
if (throwIfNoMetadata)
{
throw Error.Database_NoDatabaseMetadata();
}
return(true);
}
internal override void ApplyMigration(DbMigration migration, DbMigration lastMigration)
{
IMigrationMetadata migrationMetadata = (IMigrationMetadata)migration;
VersionedModel sourceModel1 = this.GetLastModel(lastMigration, migrationMetadata.Id);
VersionedModel sourceModel2 = migration.GetSourceModel();
VersionedModel targetModel = migration.GetTargetModel();
if (sourceModel2 != null && this.IsModelOutOfDate(sourceModel2.Model, lastMigration))
{
base.AutoMigrate(migrationMetadata.Id.ToAutomaticMigrationId(), sourceModel1, sourceModel2, false);
sourceModel1 = sourceModel2;
}
string defaultSchema = DbMigrator.GetDefaultSchema(migration);
XDocument historyModel = this.GetHistoryModel(defaultSchema);
IEnumerable <MigrationOperation> systemOperations = Enumerable.Empty <MigrationOperation>();
if (object.ReferenceEquals((object)sourceModel1.Model, (object)this._emptyModel.Value) && !base.HistoryExists())
{
systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(this._emptyModel.Value, historyModel, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null);
}
else
{
string lastDefaultSchema = this.GetLastDefaultSchema(migrationMetadata.Id);
if (!string.Equals(lastDefaultSchema, defaultSchema, StringComparison.Ordinal))
{
systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(this.GetHistoryModel(lastDefaultSchema), historyModel, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null);
}
}
migration.Up();
this.ExecuteOperations(migrationMetadata.Id, targetModel, migration.Operations, systemOperations, false, false);
}
public void GetLastModel_should_return_model_based_on_passed_context_key_when_custom_default_schema()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "LegacyKey", null, HistoryContext.DefaultFactory)
{
CurrentSchema = "foo"
};
using (var context = CreateContext <ShopContext_v1>())
{
var model = context.GetModel();
var versionedModel = new VersionedModel(model);
ExecuteOperations(
GetCreateHistoryTableOperation(historyRepository.CurrentSchema),
historyRepository.CreateInsertOperation("Migration", versionedModel));
historyRepository
= new HistoryRepository(Mock.Of <InternalContextForMock>(),
ConnectionString,
ProviderFactory,
"NewKey",
null,
HistoryContext.DefaultFactory,
schemas: new[] { "foo" });
string migrationId, _;
model = historyRepository.GetLastModel(out migrationId, out _, "LegacyKey");
Assert.NotNull(model);
Assert.Equal("Migration", migrationId);
}
}
public void GetModel_should_return_model_based_on_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "Key1", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = context.GetModel();
var versionedModel = new VersionedModel(model);
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", versionedModel));
var historyRepository2
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "Key2", null, HistoryContext.DefaultFactory);
ExecuteOperations(
new[] { historyRepository2.CreateInsertOperation("Migration 2", versionedModel) });
string productVersion;
model = historyRepository1.GetModel("Migration 1", out productVersion);
Assert.NotNull(model);
Assert.Equal(typeof(DbContext).Assembly().GetInformationalVersion(), productVersion);
string _;
model = historyRepository2.GetModel("Migration 2", out _);
Assert.NotNull(model);
}
}
public virtual void BootstrapUsingEFProviderDdl(VersionedModel versionedModel)
{
DebugCheck.NotNull(versionedModel);
DbConnection connection = null;
try
{
connection = CreateConnection();
using (var context = CreateContext(connection))
{
context.Database.ExecuteSqlCommand(
((IObjectContextAdapter)context).ObjectContext.CreateDatabaseScript());
context.History.Add(
new HistoryRow
{
MigrationId = MigrationAssembly
.CreateMigrationId(Strings.InitialCreate)
.RestrictTo(_migrationIdMaxLength),
ContextKey = _contextKey,
Model = new ModelCompressor().Compress(versionedModel.Model),
ProductVersion = versionedModel.Version ?? _productVersion
});
context.SaveChanges();
}
}
finally
{
DisposeConnection(connection);
}
}
public void GetLastModel_should_return_model_when_row()
{
ResetDatabase();
var historyRepository = new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model1 = new VersionedModel(context.GetModel());
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration 1", model1));
ExecuteOperations(
new[] { historyRepository.CreateInsertOperation("Migration 2", model1) });
string migrationId, productVersion;
var model2 = historyRepository.GetLastModel(out migrationId, out productVersion);
Assert.NotNull(model2);
Assert.True(XNode.DeepEquals(model1.Model, model2));
Assert.Equal("Migration 2", migrationId);
Assert.Equal(typeof(DbContext).Assembly().GetInformationalVersion(), productVersion);
}
}
public void GetMigrationsSince_should_return_empty_when_target_valid_but_is_latest()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("Migration1", model),
historyRepository.CreateInsertOperation("Migration2", model)
});
}
var migrations = historyRepository.GetMigrationsSince("Migration2");
Assert.Equal(0, migrations.Count());
}
public virtual MigrationOperation CreateInsertOperation(
string migrationId,
VersionedModel versionedModel)
{
DbConnection connection = (DbConnection)null;
try
{
connection = this.CreateConnection();
using (HistoryContext context = this.CreateContext(connection, (string)null))
{
context.History.Add(new HistoryRow()
{
MigrationId = migrationId.RestrictTo(this._migrationIdMaxLength),
ContextKey = this._contextKey,
Model = new ModelCompressor().Compress(versionedModel.Model),
ProductVersion = versionedModel.Version ?? HistoryRepository._productVersion
});
using (CommandTracer commandTracer = new CommandTracer((DbContext)context))
{
context.SaveChanges();
return((MigrationOperation) new HistoryOperation((IList <DbModificationCommandTree>)commandTracer.CommandTrees.OfType <DbModificationCommandTree>().ToList <DbModificationCommandTree>(), (object)null));
}
}
}
finally
{
this.DisposeConnection(connection);
}
}
public void GetMigrationId_should_throw_when_name_ambiguous()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("201109192032331_Migration", model),
historyRepository.CreateInsertOperation("201109192032332_Migration", model)
});
}
Assert.Equal(
Strings.AmbiguousMigrationName("Migration"),
Assert.Throws <MigrationsException>(() => historyRepository.GetMigrationId("Migration")).Message);
}
public void GetMigrationsSince_should_return_subset_based_on_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey1", null, HistoryContext.DefaultFactory);
var historyRepository2
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey2", null, HistoryContext.DefaultFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
new[]
{
historyRepository1.CreateInsertOperation("Migration1", model),
historyRepository1.CreateInsertOperation("Migration2", model),
historyRepository2.CreateInsertOperation("Migration1", model),
historyRepository2.CreateInsertOperation("Migration2", model)
});
}
var migrations = historyRepository1.GetMigrationsSince("Migration1");
Assert.Equal(1, migrations.Count());
Assert.Equal("Migration2", migrations.Single());
}
public void GetMigrationId_should_match_by_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey1", null, HistoryContext.DefaultFactory);
var historyRepository2
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey2", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("201109192032331_Migration1", model),
historyRepository1.CreateInsertOperation("201109192032332_Migration2", model),
historyRepository2.CreateInsertOperation("201109192032331_Migration1", model),
historyRepository2.CreateInsertOperation("201109192032332_Migration2", model)
});
}
var migrationId = historyRepository1.GetMigrationId("Migration1");
Assert.Equal("201109192032331_Migration1", migrationId);
migrationId = historyRepository1.GetMigrationId("migrATIon2");
Assert.Equal("201109192032332_Migration2", migrationId);
}
public void HasMigrations_should_return_false_when_context_key_not_matching()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey1", null, HistoryContext.DefaultFactory);
var historyRepository2
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey2", null, HistoryContext.DefaultFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
new[]
{
historyRepository2.CreateInsertOperation("Migration2", model)
});
}
Assert.False(historyRepository1.HasMigrations());
}
internal override void AutoMigrate(
string migrationId,
VersionedModel sourceModel,
VersionedModel targetModel,
bool downgrading)
{
IEnumerable <MigrationOperation> systemOperations = Enumerable.Empty <MigrationOperation>();
if (!this._historyRepository.IsShared())
{
if (object.ReferenceEquals((object)targetModel.Model, (object)this._emptyModel.Value))
{
systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(this.GetHistoryModel("dbo"), this._emptyModel.Value, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null);
}
else if (object.ReferenceEquals((object)sourceModel.Model, (object)this._emptyModel.Value))
{
systemOperations = (IEnumerable <MigrationOperation>) this._modelDiffer.Diff(this._emptyModel.Value, this._calledByCreateDatabase ? this.GetHistoryModel(this._defaultSchema) : this.GetHistoryModel("dbo"), (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, (string)null, (string)null);
}
}
List <MigrationOperation> list = this._modelDiffer.Diff(sourceModel.Model, targetModel.Model, targetModel.Model == this._currentModel ? this._modificationCommandTreeGenerator : (Lazy <ModificationCommandTreeGenerator>)null, this.SqlGenerator, sourceModel.Version, targetModel.Version).ToList <MigrationOperation>();
if (!this._calledByCreateDatabase && object.ReferenceEquals((object)targetModel.Model, (object)this._currentModel) && !string.Equals(this.GetLastDefaultSchema(migrationId), this._defaultSchema, StringComparison.Ordinal))
{
throw Error.UnableToMoveHistoryTableWithAuto();
}
if (!this._configuration.AutomaticMigrationDataLossAllowed && list.Any <MigrationOperation>((Func <MigrationOperation, bool>)(o => o.IsDestructiveChange)))
{
throw Error.AutomaticDataLoss();
}
if (targetModel.Model != this._currentModel && list.Any <MigrationOperation>((Func <MigrationOperation, bool>)(o => o is ProcedureOperation)))
{
throw Error.AutomaticStaleFunctions((object)migrationId);
}
this.ExecuteOperations(migrationId, targetModel, (IEnumerable <MigrationOperation>)list, systemOperations, downgrading, true);
}
private void ExecuteOperations(
string migrationId,
VersionedModel targetModel,
IEnumerable <MigrationOperation> operations,
IEnumerable <MigrationOperation> systemOperations,
bool downgrading,
bool auto = false)
{
DbMigrator.FillInForeignKeyOperations(operations, targetModel.Model);
List <AddForeignKeyOperation> list1 = operations.OfType <CreateTableOperation>().SelectMany((Func <CreateTableOperation, IEnumerable <AddForeignKeyOperation> >)(ct => operations.OfType <AddForeignKeyOperation>()), (ct, afk) => new
{
ct = ct,
afk = afk
}).Where(_param0 => _param0.ct.Name.EqualsIgnoreCase(_param0.afk.DependentTable)).Select(_param0 => _param0.afk).ToList <AddForeignKeyOperation>();
List <MigrationOperation> list2 = operations.Except <MigrationOperation>((IEnumerable <MigrationOperation>)list1).Concat <MigrationOperation>((IEnumerable <MigrationOperation>)list1).Concat <MigrationOperation>(systemOperations).ToList <MigrationOperation>();
CreateTableOperation createTableOperation = systemOperations.OfType <CreateTableOperation>().FirstOrDefault <CreateTableOperation>();
if (createTableOperation != null)
{
this._historyRepository.CurrentSchema = DatabaseName.Parse(createTableOperation.Name).Schema;
}
MoveTableOperation moveTableOperation = systemOperations.OfType <MoveTableOperation>().FirstOrDefault <MoveTableOperation>();
if (moveTableOperation != null)
{
this._historyRepository.CurrentSchema = moveTableOperation.NewSchema;
moveTableOperation.ContextKey = this._configuration.ContextKey;
moveTableOperation.IsSystem = true;
}
if (!downgrading)
{
list2.Add(this._historyRepository.CreateInsertOperation(migrationId, targetModel));
}
else if (!systemOperations.Any <MigrationOperation>((Func <MigrationOperation, bool>)(o => o is DropTableOperation)))
{
list2.Add(this._historyRepository.CreateDeleteOperation(migrationId));
}
IEnumerable <MigrationStatement> migrationStatements = base.GenerateStatements((IList <MigrationOperation>)list2, migrationId);
if (auto)
{
migrationStatements = migrationStatements.Distinct <MigrationStatement>((Func <MigrationStatement, MigrationStatement, bool>)((m1, m2) => string.Equals(m1.Sql, m2.Sql, StringComparison.Ordinal)));
}
base.ExecuteStatements(migrationStatements);
this._historyRepository.ResetExists();
}
private HistoryRepository SetupHistoryRepositoryForOrderingTest()
{
ResetDatabase();
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
var clonedConnection = DbProviderServices.GetProviderFactory(context.Database.Connection).CreateConnection();
clonedConnection.ConnectionString = context.Database.Connection.ConnectionString;
using (var historyContext = new HistoryContext(clonedConnection, defaultSchema: null))
{
context.InternalContext.MarkDatabaseInitialized();
context.Database.ExecuteSqlCommand(
((IObjectContextAdapter)historyContext).ObjectContext.CreateDatabaseScript());
historyContext.History.Add(
new HistoryRow
{
MigrationId = "227309030010001_Migration1",
ContextKey = "MyKey",
Model = new ModelCompressor().Compress(model.Model),
ProductVersion = "",
});
historyContext.History.Add(
new HistoryRow
{
MigrationId = "227209030010001_Migration2",
ContextKey = "MyKey",
Model = new ModelCompressor().Compress(model.Model),
ProductVersion = "",
});
historyContext.SaveChanges();
}
}
return(new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory));
}
public void GetPendingMigrations_should_ignore_InitialCreate_timestamps()
{
ResetDatabase();
var historyRepository = new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("000000000000001_InitialCreate", model));
}
var pendingMigrations = historyRepository.GetPendingMigrations(
new[] { "000000000000002_InitialCreate", "Migration 1" });
Assert.Equal("Migration 1", pendingMigrations.Single());
}
public void HasMigrations_should_return_true_when_table_has_migrations_for_key()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = new VersionedModel(context.GetModel());
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration1", model)
});
}
Assert.True(historyRepository.HasMigrations());
}
public virtual MigrationOperation CreateInsertOperation(string migrationId, VersionedModel versionedModel)
{
DebugCheck.NotEmpty(migrationId);
DebugCheck.NotNull(versionedModel);
DbConnection connection = null;
try
{
connection = CreateConnection();
using (var context = CreateContext(connection))
{
context.History.Add(
new HistoryRow
{
MigrationId = migrationId.RestrictTo(_migrationIdMaxLength),
ContextKey = _contextKey,
Model = new ModelCompressor().Compress(versionedModel.Model),
ProductVersion = versionedModel.Version ?? _productVersion
});
using (var commandTracer = new CommandTracer(context))
{
context.SaveChanges();
return(new HistoryOperation(
commandTracer.CommandTrees.OfType <DbModificationCommandTree>().ToList()));
}
}
}
finally
{
DisposeConnection(connection);
}
}
public virtual bool ModelMatches(VersionedModel model)
{
return(!new EdmModelDiffer().Diff(model.Model, this.Owner.GetModel(), (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, model.Version, (string)null).Any <MigrationOperation>());
}
internal virtual bool IsModelOutOfDate(XDocument model, DbMigration lastMigration)
{
VersionedModel lastModel = this.GetLastModel(lastMigration, (string)null);
return(this._modelDiffer.Diff(lastModel.Model, model, (Lazy <ModificationCommandTreeGenerator>)null, (MigrationSqlGenerator)null, lastModel.Version, (string)null).Any <MigrationOperation>());
}