public void GetLastModel_should_return_model_when_row()
{
ResetDatabase();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model1 = context.GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration 1", model1));
ExecuteOperations(
new[] { historyRepository.CreateInsertOperation("Migration 2", model1) });
string migrationId;
var model2 = historyRepository.GetLastModel(out migrationId);
Assert.NotNull(model2);
Assert.True(XNode.DeepEquals(model1, model2));
Assert.Equal("Migration 2", migrationId);
}
}
public void GetMigrationsSince_should_return_subset_when_target_valid()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
using (var context = CreateContext <ShopContext_v1>())
{
var model = context.GetModel();
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("Migration1", model),
historyRepository.CreateInsertOperation("Migration2", model)
});
}
var migrations = historyRepository.GetMigrationsSince("Migration1");
Assert.Equal(1, migrations.Count());
Assert.Equal("Migration2", migrations.Single());
}
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 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 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 GetMigrationsSince_should_return_subset_based_on_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1");
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2");
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext <ShopContext_v1>().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 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 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 void GetMigrationId_should_match_by_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1");
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2");
var model = CreateContext <ShopContext_v1>().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 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 GetMigrationId_should_match_on_name()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = context.GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("201109192032331_Migration1", model),
historyRepository.CreateInsertOperation("201109192032332_Migration2", model)
});
}
var migrationId = historyRepository.GetMigrationId("Migration1");
Assert.Equal("201109192032331_Migration1", migrationId);
migrationId = historyRepository.GetMigrationId("migrATIon2");
Assert.Equal("201109192032332_Migration2", migrationId);
}
public void CreateInsertOperation_should_return_valid_history_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey");
var historyOperation
= (HistoryOperation)historyRepository.CreateInsertOperation("Migration1", modelDocument);
Assert.NotEmpty(historyOperation.Commands);
Assert.Equal(4, historyOperation.Commands.Single().Parameters.Count());
}
public void GetLastModel_should_return_model_based_on_passed_context_key_when_custom_default_schema()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "LegacyKey")
{
CurrentSchema = "foo"
};
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(historyRepository.CurrentSchema),
historyRepository.CreateInsertOperation("Migration", model));
historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "NewKey", new[] { "foo" });
string migrationId;
model = historyRepository.GetLastModel(out migrationId, "LegacyKey");
Assert.NotNull(model);
Assert.Equal("Migration", migrationId);
}
public void GetLastModel_should_return_model_based_on_passed_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "Key1");
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", model));
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "Key2");
ExecuteOperations(
new[] { historyRepository2.CreateInsertOperation("Migration 2", model) });
string migrationId;
model = historyRepository1.GetLastModel(out migrationId, "Key2");
Assert.NotNull(model);
Assert.Equal("Migration 2", migrationId);
}
public void GetModel_should_return_model_based_on_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "Key1", null, HistoryContext.DefaultFactory);
using (var context = CreateContext <ShopContext_v1>())
{
var model = context.GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", model));
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "Key2", null, HistoryContext.DefaultFactory);
ExecuteOperations(
new[] { historyRepository2.CreateInsertOperation("Migration 2", model) });
model = historyRepository1.GetModel("Migration 1");
Assert.NotNull(model);
model = historyRepository2.GetModel("Migration 2");
Assert.NotNull(model);
}
}
public void CreateInsertOperation_should_return_valid_history_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(Mock.Of <InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
var historyOperation
= (HistoryOperation)historyRepository.CreateInsertOperation("Migration1", new VersionedModel(modelDocument));
Assert.NotEmpty(historyOperation.CommandTrees);
Assert.Equal(DbCommandTreeKind.Insert, historyOperation.CommandTrees.Single().CommandTreeKind);
}
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());
}
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 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 GetPendingMigrations_should_return_migrations_not_in_input_set()
{
ResetDatabase();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey");
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration 1", model),
historyRepository.CreateInsertOperation("Migration 3", model),
historyRepository.CreateInsertOperation("Migration 5", model));
var pendingMigrations =
historyRepository.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 void GetMigrationsSince_should_return_all_migrations_when_target_is_empty()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey");
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration1", model),
historyRepository.CreateInsertOperation("Migration2", model)
});
var migrations = historyRepository.GetMigrationsSince(DbMigrator.InitialDatabase);
Assert.Equal(2, migrations.Count());
Assert.Equal("Migration2", migrations.First());
}
public void GetMigrationId_should_throw_when_name_ambiguous()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey");
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext <ShopContext_v1>().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_empty_when_target_valid_but_is_latest()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("Migration1", model),
historyRepository.CreateInsertOperation("Migration2", model)
});
var migrations = historyRepository.GetMigrationsSince("Migration2");
Assert.Equal(0, migrations.Count());
}
public void GetPendingMigrations_should_ignore_InitialCreate_timestamps()
{
ResetDatabase();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey");
var model = CreateContext <ShopContext_v1>().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(ConnectionString, ProviderFactory, "MyKey", null);
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration1", model)
});
Assert.True(historyRepository.HasMigrations());
}
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 void HasMigrations_should_return_false_when_context_key_not_matching()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1", null);
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2", null);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext <ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
historyRepository2.CreateInsertOperation("Migration2", model)
});
Assert.False(historyRepository1.HasMigrations());
}
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 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 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 HasMigrations_should_return_true_when_table_has_migrations_for_key()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration1", model)
});
Assert.True(historyRepository.HasMigrations());
}
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 GetLastModel_should_return_model_based_on_passed_context_key_when_custom_default_schema()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "LegacyKey", null)
{
CurrentSchema = "foo"
};
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(historyRepository.CurrentSchema),
historyRepository.CreateInsertOperation("Migration", model));
historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "NewKey", null, new[] { "foo" });
string migrationId;
model = historyRepository.GetLastModel(out migrationId, "LegacyKey");
Assert.NotNull(model);
Assert.Equal("Migration", migrationId);
}
public void CreateInsertOperation_should_return_valid_history_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(Mock.Of<InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
var historyOperation
= (HistoryOperation)historyRepository.CreateInsertOperation("Migration1", modelDocument);
Assert.NotEmpty(historyOperation.CommandTrees);
Assert.Equal(DbCommandTreeKind.Insert, historyOperation.CommandTrees.Single().CommandTreeKind);
}
public void GetMigrationsSince_should_return_empty_when_target_valid_but_is_latest()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("Migration1", model)
});
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("Migration2", model)
});
var migrations = historyRepository.GetMigrationsSince("Migration2");
Assert.Equal(0, migrations.Count());
}
public void GetMigrationsSince_should_return_subset_based_on_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1", null);
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2", null);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext<ShopContext_v1>().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 CreateInsertOperation_should_return_valid_history_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
var historyOperation
= (HistoryOperation)historyRepository.CreateInsertOperation("Migration1", modelDocument);
Assert.NotEmpty(historyOperation.Commands);
Assert.Equal(4, historyOperation.Commands.Single().Parameters.Count);
}
public void CreateInsertOperation_should_return_valid_add_operation()
{
var modelBuilder = new DbModelBuilder();
var model = modelBuilder.Build(ProviderInfo);
var edmxString = new StringBuilder();
using (var xmlWriter = XmlWriter.Create(
edmxString, new XmlWriterSettings
{
Indent = true
}))
{
EdmxWriter.WriteEdmx(model, xmlWriter);
}
var modelDocument = model.GetModel();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory);
var insertHistoryOperation
= (InsertHistoryOperation)historyRepository.CreateInsertOperation("Migration1", modelDocument);
Assert.Equal("Migration1", insertHistoryOperation.MigrationId);
Assert.Equal(new ModelCompressor().Compress(modelDocument), (object)insertHistoryOperation.Model);
}
public void GetMigrationId_should_match_by_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1", null);
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2", null);
var model = CreateContext<ShopContext_v1>().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 GetLastModel_should_return_model_based_on_passed_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();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", model));
var historyRepository2
= new HistoryRepository(Mock.Of<InternalContextForMock>(), ConnectionString, ProviderFactory, "Key2", null, HistoryContext.DefaultFactory);
ExecuteOperations(
new[] { historyRepository2.CreateInsertOperation("Migration 2", model) });
string migrationId, _;
model = historyRepository1.GetLastModel(out migrationId, out _, "Key2");
Assert.NotNull(model);
Assert.Equal("Migration 2", migrationId);
}
}
public void GetPendingMigrations_should_ignore_InitialCreate_timestamps()
{
ResetDatabase();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
var model = CreateContext<ShopContext_v1>().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 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();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", model));
var historyRepository2
= new HistoryRepository(Mock.Of<InternalContextForMock>(), ConnectionString, ProviderFactory, "Key2", null, HistoryContext.DefaultFactory);
ExecuteOperations(
new[] { historyRepository2.CreateInsertOperation("Migration 2", model) });
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 void GetMigrationId_should_match_on_name()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("201109192032331_Migration1", model)
});
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("201109192032332_Migration2", model)
});
var migrationId = historyRepository.GetMigrationId("Migration1");
Assert.Equal("201109192032331_Migration1", migrationId);
migrationId = historyRepository.GetMigrationId("migrATIon2");
Assert.Equal("201109192032332_Migration2", migrationId);
}
public void HasMigrations_should_return_false_when_context_key_not_matching()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1", null);
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2", null);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
historyRepository2.CreateInsertOperation("Migration2", model)
});
Assert.False(historyRepository1.HasMigrations());
}
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 = context.GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration1", model)
});
}
Assert.True(historyRepository.HasMigrations());
}
public void GetMigrationId_should_throw_when_name_ambiguous()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
ExecuteOperations(GetCreateHistoryTableOperation());
var model = CreateContext<ShopContext_v1>().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 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 = context.GetModel();
ExecuteOperations(
new[]
{
historyRepository2.CreateInsertOperation("Migration2", model)
});
}
Assert.False(historyRepository1.HasMigrations());
}
public void GetPendingMigrations_should_return_migrations_based_on_context_key()
{
ResetDatabase();
var historyRepository1 = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey1", null);
var historyRepository2 = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey2", null);
var model = CreateContext<ShopContext_v1>().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 void GetMigrationId_should_match_on_name()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(Mock.Of<InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext<ShopContext_v1>())
{
var model = context.GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("201109192032331_Migration1", model),
historyRepository.CreateInsertOperation("201109192032332_Migration2", model)
});
}
var migrationId = historyRepository.GetMigrationId("Migration1");
Assert.Equal("201109192032331_Migration1", migrationId);
migrationId = historyRepository.GetMigrationId("migrATIon2");
Assert.Equal("201109192032332_Migration2", migrationId);
}
public void GetLastModel_should_return_model_when_row()
{
ResetDatabase();
var historyRepository = new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
var model1 = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration 1", model1));
ExecuteOperations(
new[] { historyRepository.CreateInsertOperation("Migration 2", model1) });
string migrationId;
var model2 = historyRepository.GetLastModel(out migrationId);
Assert.NotNull(model2);
Assert.True(XNode.DeepEquals(model1, model2));
Assert.Equal("Migration 2", migrationId);
}
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 = context.GetModel();
ExecuteOperations(
new[]
{
historyRepository.CreateInsertOperation("Migration1", model),
historyRepository.CreateInsertOperation("Migration2", model)
});
}
var migrations = historyRepository.GetMigrationsSince("Migration2");
Assert.Equal(0, migrations.Count());
}
public void GetModel_should_return_model_based_on_context_key()
{
ResetDatabase();
var historyRepository1
= new HistoryRepository(ConnectionString, ProviderFactory, "Key1", null);
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository1.CreateInsertOperation("Migration 1", model));
var historyRepository2
= new HistoryRepository(ConnectionString, ProviderFactory, "Key2", null);
ExecuteOperations(
new[] { historyRepository2.CreateInsertOperation("Migration 2", model) });
model = historyRepository1.GetModel("Migration 1");
Assert.NotNull(model);
model = historyRepository2.GetModel("Migration 2");
Assert.NotNull(model);
}
public void GetPendingMigrations_should_return_migrations_not_in_input_set()
{
ResetDatabase();
var historyRepository = new HistoryRepository(Mock.Of<InternalContextForMock>(), ConnectionString, ProviderFactory, "MyKey", null, HistoryContext.DefaultFactory);
using (var context = CreateContext<ShopContext_v1>())
{
var model = context.GetModel();
ExecuteOperations(
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration 1", model),
historyRepository.CreateInsertOperation("Migration 3", model),
historyRepository.CreateInsertOperation("Migration 5", model));
}
var pendingMigrations =
historyRepository.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 void GetMigrationsSince_should_return_all_migrations_when_target_is_empty()
{
ResetDatabase();
var historyRepository
= new HistoryRepository(ConnectionString, ProviderFactory, "MyKey", null);
var model = CreateContext<ShopContext_v1>().GetModel();
ExecuteOperations(
new[]
{
GetCreateHistoryTableOperation(),
historyRepository.CreateInsertOperation("Migration1", model),
historyRepository.CreateInsertOperation("Migration2", model)
});
var migrations = historyRepository.GetMigrationsSince(DbMigrator.InitialDatabase);
Assert.Equal(2, migrations.Count());
Assert.Equal("Migration2", migrations.First());
}
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 = 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, model2));
Assert.Equal("Migration 2", migrationId);
Assert.Equal(typeof(DbContext).Assembly().GetInformationalVersion(), productVersion);
}
}
