public async Task Should_Initialize_Single_Module_Async()
{
using (var application = await AbpApplicationFactory.CreateAsync <IndependentEmptyModule>())
{
//Assert
var module = application.Services.GetSingletonInstance <IndependentEmptyModule>();
module.PreConfigureServicesAsyncIsCalled.ShouldBeTrue();
module.PreConfigureServicesIsCalled.ShouldBeTrue();
module.ConfigureServicesAsyncIsCalled.ShouldBeTrue();
module.ConfigureServicesIsCalled.ShouldBeTrue();
module.PostConfigureServicesAsyncIsCalled.ShouldBeTrue();
module.PostConfigureServicesIsCalled.ShouldBeTrue();
//Act
await application.InitializeAsync();
//Assert
application.ServiceProvider.GetRequiredService <IndependentEmptyModule>().ShouldBeSameAs(module);
module.OnApplicationInitializeAsyncIsCalled.ShouldBeTrue();
module.OnApplicationInitializeIsCalled.ShouldBeTrue();
//Act
await application.ShutdownAsync();
//Assert
module.OnApplicationShutdownAsyncIsCalled.ShouldBeTrue();
module.OnApplicationShutdownIsCalled.ShouldBeTrue();
}
}
protected async override void OnStartup(StartupEventArgs e)
{
Log.Logger = new LoggerConfiguration()
#if DEBUG
.MinimumLevel.Debug()
#else
.MinimumLevel.Information()
#endif
.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
.Enrich.FromLogContext()
.WriteTo.Async(c => c.File("Logs/logs.txt"))
.CreateLogger();
try
{
Log.Information("Starting WPF host.");
_abpApplication = await AbpApplicationFactory.CreateAsync <MyProjectNameModule>(options =>
{
options.UseAutofac();
options.Services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true));
});
await _abpApplication.InitializeAsync();
_abpApplication.Services.GetRequiredService <MainWindow>()?.Show();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly!");
}
}
public async static Task <IAbpApplicationWithExternalServiceProvider> AddApplicationAsync(
[NotNull] this IServiceCollection services,
[NotNull] Type startupModuleType,
[CanBeNull] Action <AbpApplicationCreationOptions> optionsAction = null)
{
return(await AbpApplicationFactory.CreateAsync(startupModuleType, services, optionsAction));
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using (var application = await AbpApplicationFactory.CreateAsync <EShopSampleConsoleApiClientModule>())
{
await application.InitializeAsync();
var demo = application.ServiceProvider.GetRequiredService <ClientDemoService>();
await demo.RunAsync();
await application.ShutdownAsync();
}
}
public async Task AutoServiceRegistration_Should_Not_Duplicate_Test_Async()
{
using (var application = await AbpApplicationFactory.CreateAsync <TestModule>())
{
//Act
await application.InitializeAsync();
//Assert
var services = application.ServiceProvider.GetServices <TestService>().ToList();
services.Count.ShouldBe(1);
}
}
protected virtual async Task <TContext> CreateDbContextAsync(string[] args)
{
var application = await AbpApplicationFactory.CreateAsync <TModule>(options =>
{
options.Services.ReplaceConfiguration(BuildConfiguration());
ConfigureServices(options.Services);
});
await application.InitializeAsync();
return(application.ServiceProvider.GetRequiredService <TContext>());
}
public async Task Should_Use_Empty_ConfigurationRoot_By_Default_Async()
{
using (var application = await AbpApplicationFactory.CreateAsync <IndependentEmptyModule>())
{
var configuration1 = application.Services.GetConfiguration();
configuration1.ShouldNotBeNull();
await application.InitializeAsync();
var configuration2 = ResolveConfiguration(application);
configuration2.ShouldBe(configuration1);
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using (var application = await AbpApplicationFactory.CreateAsync <DynamicQuerySampleConsoleApiClientModule>(options =>
{
options.Services.ReplaceConfiguration(_configuration);
}))
{
await application.InitializeAsync();
var demo = application.ServiceProvider.GetRequiredService <ClientDemoService>();
await demo.RunAsync();
await application.ShutdownAsync();
}
}
public async Task Should_Use_The_Registered_ConfigurationRoot_Async()
{
using (var application = await AbpApplicationFactory.CreateAsync <IndependentEmptyModule>())
{
var myConfiguration = new ConfigurationBuilder().Build();
application.Services.ReplaceConfiguration(myConfiguration);
application.Services.GetConfiguration().ShouldBe(myConfiguration);
await application.InitializeAsync();
var configuration = ResolveConfiguration(application);
configuration.ShouldBe(myConfiguration);
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_abpApplication = await AbpApplicationFactory.CreateAsync <EasyStoreConsoleAppAppModule>(options =>
{
options.Services.ReplaceConfiguration(_configuration);
options.Services.AddSingleton(_hostEnvironment);
options.UseAutofac();
options.Services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog());
});
await _abpApplication.InitializeAsync();
var helloWorldService = _abpApplication.ServiceProvider.GetRequiredService <HelloWorldService>();
await helloWorldService.SayHelloAsync();
}
public async Task Should_Use_Default_ServiceScopeFactory_By_Default_Async()
{
using (var application = await AbpApplicationFactory.CreateAsync <IndependentEmptyModule>())
{
application.Services.AddType(typeof(MyServiceAsync));
await application.InitializeAsync();
var serviceScopeFactory = application.ServiceProvider.GetRequiredService <IHybridServiceScopeFactory>();
using (var scope = serviceScopeFactory.CreateScope())
{
scope.ServiceProvider.GetRequiredService <MyServiceAsync>();
}
MyServiceAsync.DisposeCount.ShouldBe(1);
}
}
public async Task Should_Initialize_PlugIn_Async()
{
using (var application = await AbpApplicationFactory.CreateAsync <IndependentEmptyModule>(options =>
{
options.PlugInSources.AddTypes(typeof(IndependentEmptyPlugInModule));
}))
{
//Assert
var plugInModule = application.Services.GetSingletonInstance <IndependentEmptyPlugInModule>();
plugInModule.PreConfigureServicesAsyncIsCalled.ShouldBeTrue();
plugInModule.PreConfigureServicesIsCalled.ShouldBeTrue();
plugInModule.ConfigureServicesAsyncIsCalled.ShouldBeTrue();
plugInModule.ConfigureServicesIsCalled.ShouldBeTrue();
plugInModule.PostConfigureServicesAsyncIsCalled.ShouldBeTrue();
plugInModule.PostConfigureServicesIsCalled.ShouldBeTrue();
//Act
await application.InitializeAsync();
//Assert
application.ServiceProvider.GetRequiredService <IndependentEmptyPlugInModule>().ShouldBeSameAs(plugInModule);
plugInModule.OnPreApplicationInitializationAsyncIsCalled.ShouldBeTrue();
plugInModule.OnPreApplicationInitializationIsCalled.ShouldBeTrue();
plugInModule.OnApplicationInitializeAsyncIsCalled.ShouldBeTrue();
plugInModule.OnApplicationInitializeIsCalled.ShouldBeTrue();
plugInModule.OnPostApplicationInitializationAsyncIsCalled.ShouldBeTrue();
plugInModule.OnPostApplicationInitializationIsCalled.ShouldBeTrue();
//Act
await application.ShutdownAsync();
//Assert
plugInModule.OnApplicationShutdownAsyncIsCalled.ShouldBeTrue();
plugInModule.OnApplicationShutdownIsCalled.ShouldBeTrue();
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
using (var application = await AbpApplicationFactory.CreateAsync <MyProjectDbMigratorModule>(options =>
{
options.UseAutofac();
options.Services.AddLogging(c => c.AddSerilog());
}))
{
await application.InitializeAsync();
await application
.ServiceProvider
.GetRequiredService <MyProjectDbMigrationService>()
.MigrateAsync();
await application.ShutdownAsync();
_hostApplicationLifetime.StopApplication();
}
}
