public async Task Exception_while_applying_migrations()
{
var database = await SqlServerTestDatabase.Scratch(createDatabase : false);
var options = new DbContextOptions().UseSqlServer(database.Connection.ConnectionString);
TestServer server = TestServer.Create(app =>
{
app.UseServices(services =>
{
services.AddEntityFramework().AddSqlServer();
services.AddScoped <BloggingContextWithSnapshotThatThrows>();
services.AddInstance <DbContextOptions>(options);
});
app.UseMigrationsEndPoint();
});
var formData = new FormUrlEncodedContent(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("context", typeof(BloggingContextWithSnapshotThatThrows).AssemblyQualifiedName)
});
var ex = await Assert.ThrowsAsync <InvalidOperationException>(async() =>
await server.CreateClient().PostAsync("http://localhost" + MigrationsEndPointOptions.DefaultPath, formData));
Assert.Equal(StringsHelpers.GetResourceString("FormatMigrationsEndPointMiddleware_Exception", typeof(BloggingContextWithSnapshotThatThrows)), ex.Message);
Assert.Equal("Welcome to the invalid migration!", ex.InnerException.Message);
}
private static async Task <TestServer> SetupTestServer <TContext, TMiddleware>(ILoggerProvider logProvider = null)
where TContext : DbContext
{
var database = await SqlServerTestDatabase.Scratch(createDatabase : false);
return(TestServer.Create(app =>
{
app.UseServices(services =>
{
services.AddEntityFramework()
.AddSqlServer();
services.AddScoped <TContext>();
services.AddInstance <DbContextOptions>(
new DbContextOptions()
.UseSqlServer(database.Connection.ConnectionString));
});
app.UseDatabaseErrorPage();
app.UseMiddleware <TMiddleware>();
if (logProvider != null)
{
app.ApplicationServices.GetService <ILoggerFactory>().AddProvider(logProvider);
}
}));
}
public async Task Pass_thru_when_context_not_in_services()
{
var database = await SqlServerTestDatabase.Scratch(createDatabase : false);
var logProvider = new TestLoggerProvider();
var server = TestServer.Create(app =>
{
app.UseServices(services =>
{
services.AddEntityFramework()
.AddSqlServer();
services.AddInstance <DbContextOptions>(
new DbContextOptions()
.UseSqlServer(database.Connection.ConnectionString));
});
app.UseDatabaseErrorPage();
app.UseMiddleware <ContextNotRegisteredInServicesMiddleware>();
app.ApplicationServices.GetService <ILoggerFactory>().AddProvider(logProvider);
});
var ex = await Assert.ThrowsAsync <SqlException>(async() =>
await server.CreateClient().GetAsync("http://localhost/"));
Assert.True(logProvider.Logger.Messages.Any(m =>
m.StartsWith(StringsHelpers.GetResourceString("FormatDatabaseErrorPageMiddleware_ContextNotRegistered", typeof(BloggingContext)))));
}
public async Task Customize_migrations_end_point()
{
var migrationsEndpoint = "/MyCustomEndPoints/ApplyMyMigrationsHere";
var database = await SqlServerTestDatabase.Scratch(createDatabase : false);
var server = TestServer.Create(app =>
{
app.UseServices(services =>
{
services.AddEntityFramework().AddSqlServer();
services.AddScoped <BloggingContextWithMigrations>();
services.AddInstance <DbContextOptions>(new DbContextOptions().UseSqlServer(database.Connection.ConnectionString));
});
var options = DatabaseErrorPageOptions.ShowAll;
options.MigrationsEndPointPath = new PathString(migrationsEndpoint);
app.UseDatabaseErrorPage(options);
app.UseMiddleware <PendingMigrationsMiddleware>();
});
HttpResponseMessage response = await server.CreateClient().GetAsync("http://localhost/");
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
Assert.Contains("req.open(\"POST\", \"" + migrationsEndpoint + "\", true);", content);
}
private async Task Migration_request(bool useCustomPath)
{
var database = await SqlServerTestDatabase.Scratch(createDatabase : false);
var options = new DbContextOptions().UseSqlServer(database.Connection.ConnectionString);
var path = useCustomPath ? new PathString("/EndPoints/ApplyMyMigrations") : MigrationsEndPointOptions.DefaultPath;
TestServer server = TestServer.Create(app =>
{
app.UseServices(services =>
{
services.AddEntityFramework().AddSqlServer();
services.AddScoped <BloggingContextWithMigrations>();
services.AddInstance <DbContextOptions>(options);
});
if (useCustomPath)
{
app.UseMigrationsEndPoint(new MigrationsEndPointOptions {
Path = path
});
}
else
{
app.UseMigrationsEndPoint();
}
});
using (var db = BloggingContextWithMigrations.CreateWithoutExternalServiceProvider(options))
{
Assert.False(db.Database.AsRelational().Exists());
var formData = new FormUrlEncodedContent(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("context", typeof(BloggingContextWithMigrations).AssemblyQualifiedName)
});
HttpResponseMessage response = await server.CreateClient()
.PostAsync("http://localhost" + path, formData);
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
Assert.True(db.Database.AsRelational().Exists());
var services = (MigrationsDataStoreServices)db.Configuration.DataStoreServices;
var appliedMigrations = services.Migrator.GetDatabaseMigrations();
Assert.Equal(2, appliedMigrations.Count);
Assert.Equal("111111111111111_MigrationOne", appliedMigrations.ElementAt(0).GetMigrationId());
Assert.Equal("222222222222222_MigrationTwo", appliedMigrations.ElementAt(1).GetMigrationId());
}
}
public async Task Pass_thru_when_exception_in_logic()
{
var database = await SqlServerTestDatabase.Scratch(createDatabase : false);
var logProvider = new TestLoggerProvider();
var server = await SetupTestServer <BloggingContextWithSnapshotThatThrows, ExceptionInLogicMiddleware>(logProvider);
var ex = await Assert.ThrowsAsync <SqlException>(async() =>
await server.CreateClient().GetAsync("http://localhost/"));
Assert.True(logProvider.Logger.Messages.Any(m =>
m.StartsWith(StringsHelpers.GetResourceString("FormatDatabaseErrorPageMiddleware_Exception"))));
}
public BloggingContext(SqlServerTestDatabase testDatabase)
: base(CreateServiceProvider())
{
_testDatabase = testDatabase;
}
private static async Task RunDatabaseCreationTest(SqlServerTestDatabase testDatabase, bool async)
{
using (var context = new BloggingContext(testDatabase))
{
Assert.Equal(ConnectionState.Closed, context.Database.AsRelational().Connection.DbConnection.State);
if (async)
{
Assert.True(await context.Database.AsRelational().EnsureCreatedAsync());
}
else
{
Assert.True(context.Database.AsRelational().EnsureCreated());
}
Assert.Equal(ConnectionState.Closed, context.Database.AsRelational().Connection.DbConnection.State);
if (testDatabase.Connection.State != ConnectionState.Open)
{
await testDatabase.Connection.OpenAsync();
}
var tables = await testDatabase.QueryAsync<string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES");
Assert.Equal(1, tables.Count());
Assert.Equal("Blog", tables.Single());
var columns = (await testDatabase.QueryAsync<string>(
"SELECT TABLE_NAME + '.' + COLUMN_NAME + ' (' + DATA_TYPE + ')' FROM INFORMATION_SCHEMA.COLUMNS")).ToArray();
Assert.Equal(19, columns.Length);
Assert.Equal(
new[]
{
"Blog.AndChew (varbinary)",
"Blog.AndRow (timestamp)",
"Blog.Cheese (nvarchar)",
"Blog.CupOfChar (int)",
"Blog.ErMilan (int)",
"Blog.Fuse (smallint)",
"Blog.George (bit)",
"Blog.Key1 (nvarchar)",
"Blog.Key2 (varbinary)",
"Blog.NotFigTime (datetime2)",
"Blog.NotToEat (smallint)",
"Blog.On (real)",
"Blog.OrNothing (float)",
"Blog.OrULong (int)",
"Blog.OrUShort (numeric)",
"Blog.OrUSkint (bigint)",
"Blog.TheGu (uniqueidentifier)",
"Blog.ToEat (tinyint)",
"Blog.WayRound (bigint)"
},
columns);
}
}
private static SqlServerDataStoreCreator GetDataStoreCreator(SqlServerTestDatabase testDatabase)
{
return CreateConfiguration(testDatabase).Services.ServiceProvider.GetService<SqlServerDataStoreCreator>();
}
private static DbContextConfiguration CreateConfiguration(SqlServerTestDatabase testDatabase)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddEntityFramework().AddSqlServer();
return new DbContext(
serviceCollection.BuildServiceProvider(),
new DbContextOptions().UseSqlServer(testDatabase.Connection.ConnectionString))
.Configuration;
}
