public AdminControllerTestsFixture()
{
var services = new ServiceCollection();
services.AddEntityFrameworkInMemoryDatabase()
.AddDbContext <ApplicationDbContext>(o => o.UseInMemoryDatabase(Guid.NewGuid().ToString()));
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <ApplicationDbContext>();
services.AddLogging();
// Taken from https://github.com/aspnet/MusicStore/blob/dev/test/MusicStore.Test/ManageControllerTest.cs (and modified)
// IHttpContextAccessor is required for SignInManager, and UserManager
var context = new DefaultHttpContext();
context.Features.Set <IHttpAuthenticationFeature>(new HttpAuthenticationFeature {
Handler = new TestAuthHandler()
});
services.AddSingleton <IHttpContextAccessor>(h => new HttpContextAccessor {
HttpContext = context
});
var serviceProvider = services.BuildServiceProvider();
Context = serviceProvider.GetService <ApplicationDbContext>();
Context.Database.EnsureCreated();
DatabaseInitialization.Initialize(Context);
UserManager = serviceProvider.GetService <UserManager <ApplicationUser> >();
}
public static async Task Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
// Initialize the database
try
{
using (var scope = host.Services.CreateScope())
{
using (var dbContext = scope.ServiceProvider.GetService <ApplicationDbContext>())
{
dbContext.Database.Migrate();
DatabaseInitialization.Initialize(dbContext);
}
// If using azure, containers must be intialized before they can be accessed
if (scope.ServiceProvider.GetRequiredService <IFileManager>() is AzureBlobFileManager azureBlobHandler)
{
await azureBlobHandler.EnsureContainerCreated(AppConstants.PROJECTS_CONTAINER);
}
}
}
catch
{
/* Don't catch database initialization error at startup */
}
await host.RunAsync();
}
public static void Main(string[] args)
{
IHost host = CreateHostBuilder(args).Build();
IMessageQueue messageQueue = host
.Services
.GetRequiredService <IMessageQueue>();
messageQueue.Connect();
ICommandsHelper commandsHelper = host
.Services
.GetRequiredService <ICommandsHelper>();
commandsHelper.AddCommand("stock");
var userManager = host
.Services
.GetRequiredService <UserManager <ChatUser> >();
var logger = host
.Services
.GetRequiredService <ILogger <DatabaseInitialization> >();
var chatRoomService = host
.Services
.GetRequiredService <IChatRoomService>();
DatabaseInitialization.Initialize(userManager,
logger,
chatRoomService);
host.Run();
}
public static void Main(string[] args)
{
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
DatabaseInitialization.InitializeDatabase(services);
var commandBus = services.GetRequiredService <ICommandBus>();
if (commandBus != null)
{
commandBus.ExecuteAsync(new CacheSettingCommand()).Wait();
}
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred Initializing the DB.");
}
}
host.Run();
}
public ProjectsControllerTests(InMemoryControllerTestsFixture fixture)
{
UserManager = fixture.UserManager;
fixture.Context.Database.EnsureDeleted();
fixture.Context.Database.EnsureCreated();
DatabaseInitialization.Initialize(fixture.Context);
}
public EditProject(AdminControllerTestsFixture fixture)
{
Context = fixture.Context;
UserManager = fixture.UserManager;
Context.Database.EnsureDeleted();
Context.Database.EnsureCreated();
DatabaseInitialization.Initialize(Context);
}
private void InsertInitialData(ISession session)
{
var init = new DatabaseInitialization {
InitDate = DateTime.Now
};
session.Save(init);
session.Flush();
}
public void Initialize()
{
builder = new DbContextOptionsBuilder <MovieAppContext>();
builder.UseInMemoryDatabase(databaseName: "testMovieAppDb");
context = new MovieAppContext(builder.Options);
//data seed
DatabaseInitialization.InitDatabaseContext(context);
actorService = new ActorService(context);
}
public DataSeed(XmlSeederFacade xmlSeederFacade, IOptions <DatabaseInitialization> initializationSettings,
IOptions <ImagesSettings> imagesSettings, Unidecode unidecode, ProductsDataSeed productsDataSeed, IImageResizer imageResizer)
{
_xmlSeederFacade = xmlSeederFacade;
_initializationSettings = initializationSettings.Value;
_imagesSettings = imagesSettings.Value;
_unidecode = unidecode;
_productsDataSeed = productsDataSeed;
_imageResizer = imageResizer;
}
public CreateNewUser(InMemoryControllerTestsFixture fixture)
{
Context = fixture.Context;
UserManager = fixture.UserManager;
SignInManager = fixture.SignInManager;
LoggerFactory = fixture.LoggerFactory;
ServiceProvider = fixture.ServiceProvider;
Context.Database.EnsureDeleted();
Context.Database.EnsureCreated();
DatabaseInitialization.Initialize(Context);
}
public async Task <ClientRegistration> NewClient()
{
ClientRegistration result;
await using (var context = Factory.AppFixture.NewDatabaseContext())
{
result = DatabaseInitialization.CreateFakeClient(context);
await context.SaveChangesAsync();
}
return(result);
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
builder.ApplyConfiguration(new AuthorConfiguration());
builder.ApplyConfiguration(new AuthorInPrintingEditionConfiguration());
builder.ApplyConfiguration(new OrderConfiguration());
builder.ApplyConfiguration(new OrderItemConfiguration());
builder.ApplyConfiguration(new PaymentConfiguration());
builder.ApplyConfiguration(new PrintingEditionConfiguration());
DatabaseInitialization.Initialize(builder);
}
public DatabaseInitializationTestsFixture()
{
var services = new ServiceCollection();
services.AddEntityFrameworkInMemoryDatabase()
.AddDbContext <ApplicationDbContext>(o => o.UseInMemoryDatabase(Guid.NewGuid().ToString()));
var serviceProvider = services.BuildServiceProvider();
Context = serviceProvider.GetService <ApplicationDbContext>();
Context.Database.EnsureCreated();
DatabaseInitialization.Initialize(Context);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
IDatabaseInitializer <DatabaseContext> init = new DatabaseInitialization();
Database.SetInitializer(init);
init.InitializeDatabase(new DatabaseContext());
Dal d = new Dal();
d.InitializeDatabase();
}
/// <summary>
/// Configures the specified application.
/// </summary>
/// <param name="app">The application.</param>
/// <param name="env">The env.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="serviceProvider">The service provider.</param>
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IServiceProvider serviceProvider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMiddleware <ExceptionsMiddleware>(serviceProvider.GetService <ILoggerService>());
app.UseResponseCompression();
app.ConfigureAuthentication();
app.UseMvc();
DatabaseInitialization.InitDatabase(app, env, serviceProvider);
}
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <LibraryContext>();
DatabaseInitialization.Initialize(context);
}
catch (Exception e)
{
logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(e, "An error occured");
}
}
host.Run();
}
public static void Main(string[] args)
{
var host = BuildWebHost(args);
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
DatabaseInitialization.InitializeDatabase(services);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred Initializing the DB.");
}
}
host.Run();
}
public override void Specify()
{
then("the database scripts can be loaded", delegate
{
var createScripts = DatabaseInitialization.GetCreateScript();
Assert.That(createScripts.Any(s => s.Contains("TABLE")), Is.True);
Assert.That(createScripts.Count(), Is.GreaterThan(5));
});
given("a path for the MDF file", delegate
{
var databaseMdfFilepath = arrange(delegate
{
string cTemp = Properties.Settings.Default.AccessibleTempPath;
var databaseTempDirectory = Path.Combine(cTemp, "RavenDBMembershipTest");
if (!Directory.Exists(databaseTempDirectory))
{
Directory.CreateDirectory(databaseTempDirectory);
}
return(Path.Combine(databaseTempDirectory, @"TestSqlMembership.mdf"));
});
then("the database can be generated", delegate
{
string databaseName = FixtureConstants.DatabaseName;
DatabaseInitialization.RecreateDatabase(databaseName, databaseMdfFilepath);
DatabaseInitialization.RunSqlMembershipCreationScript(databaseName);
});
});
}
public override void Specify()
{
when("using SqlMembershipProvider", delegate
{
var membershipOverride = new OverrideForSqlMembershipProvider();
arrange_membership_provider(membershipOverride);
then_membership_provider_should_be <SqlMembershipProvider>();
then("the connection string is set", delegate
{
var connectionStringField = typeof(SqlMembershipProvider).GetField("_sqlConnectionString", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.That(connectionStringField, Is.Not.Null);
string connectionStringValue = (string)connectionStringField.GetValue(Membership.Provider);
expect(() => connectionStringValue == DatabaseInitialization.GetConnectionStringFor(FixtureConstants.DatabaseName));
});
});
when("using RavenDBMembershipProvider embedded in-memory", delegate
{
var membershipOverride = new OverrideForInMemoryRavenMembershipProvider();
arrange_membership_provider(membershipOverride);
then_membership_provider_should_be <RavenDBMembershipProvider>();
then("RavenDB store is configured to run munin in memory", delegate
{
Assert.That(GetMembershipDocumentStore(), Is.InstanceOf <EmbeddableDocumentStore>());
expect(() => GetMembershipDocumentConfiguration().RunInMemory);
expect(() => String.IsNullOrEmpty(GetMembershipDocumentConfiguration().DataDirectory) ||
!Directory.Exists(GetMembershipDocumentConfiguration().DataDirectory));
});
});
when("using RavenDBMembershipProvider embedded w/ munin on disk", delegate
{
var membershipOverride = new OverrideForMuninRavenMembershipProvider();
arrange_membership_provider(membershipOverride);
then_membership_provider_should_be <RavenDBMembershipProvider>();
then("RavenDB store is configured to use munin stored in disk", delegate
{
Assert.That(GetMembershipDocumentStore(), Is.InstanceOf <EmbeddableDocumentStore>());
expect(() => !GetMembershipDocumentConfiguration().RunInMemory);
expect(() => !String.IsNullOrEmpty(GetMembershipDocumentConfiguration().DataDirectory));
expect_embedded_TransactionalStorage_FriendlyName_is("Munin");
});
});
when("using RavenDBMembershipProvider embedded w/ esent on disk", delegate
{
var membershipOverride = new OverrideForEsentRavenMembershipProvider();
arrange_membership_provider(membershipOverride);
then_membership_provider_should_be <RavenDBMembershipProvider>();
then("RavenDB store is configured to use esent", delegate()
{
expect(() => !GetMembershipDocumentConfiguration().RunInMemory);
expect(() => !String.IsNullOrEmpty(GetMembershipDocumentConfiguration().DataDirectory));
expect_embedded_TransactionalStorage_FriendlyName_is("Esent");
});
});
}
