Add `AbpAsyncIntegratedTest`.

framework/src/Volo.Abp.AspNetCore.TestBase/Volo/Abp/AspNetCore/TestBase/AbpAspNetCoreAsyncIntegratedTestBase.cs

@@ -14,9 +14,9 @@ using Volo.Abp.Modularity;
 namespace Volo.Abp.AspNetCore.TestBase;
 
 public class AbpAspNetCoreAsyncIntegratedTestBase<TModule>
-    where TModule : AbpModule
+    where TModule : IAbpModule
 {
-    protected IHost Host { get; set; }
+    protected WebApplication WebApplication { get; set; }
 
     protected TestServer Server { get; set; }
 
@@ -50,26 +50,20 @@ public class AbpAspNetCoreAsyncIntegratedTestBase<TModule>
         });
 
         await ConfigureServicesAsync(builder.Services);
+        WebApplication = builder.Build();
+        await WebApplication.InitializeApplicationAsync();
+        await WebApplication.StartAsync();
 
-        var app = builder.Build();
-
-        await app.InitializeApplicationAsync();
-
-        await app.StartAsync();
-
-        Host = app.Services.GetRequiredService<IHost>();
-
-        Server = Host.GetTestServer();
-        Client = Host.GetTestClient();
+        Server = WebApplication.Services.GetRequiredService<IHost>().GetTestServer();
+        Client = Server.CreateClient();
 
         ServiceProvider = Server.Services;
-
         ServiceProvider.GetRequiredService<ITestServerAccessor>().Server = Server;
     }
 
-    public virtual Task DisposeAsync()
+    public virtual async Task DisposeAsync()
     {
-        return Task.CompletedTask;
+        await WebApplication.DisposeAsync();
     }
 
     protected virtual Task ConfigureServicesAsync(IServiceCollection services)

framework/src/Volo.Abp.AspNetCore.TestBase/Volo/Abp/AspNetCore/TestBase/AbpAspNetCoreIntegratedTestBase.cs

@@ -17,8 +17,6 @@ public abstract class AbpAspNetCoreIntegratedTestBase<TStartup> : AbpTestBaseWit
 
     protected HttpClient Client { get; }
 
-    protected override IServiceProvider ServiceProvider { get; }
-
     private readonly IHost _host;
 
     protected AbpAspNetCoreIntegratedTestBase()

framework/src/Volo.Abp.TestBase/Volo/Abp/AbpTestBaseWithServiceProvider.cs

@@ -5,7 +5,7 @@ namespace Volo.Abp;
 
 public abstract class AbpTestBaseWithServiceProvider
 {
-    protected abstract IServiceProvider ServiceProvider { get; }
+    protected IServiceProvider ServiceProvider { get; set; }
 
     protected virtual T GetService<T>()
     {

framework/src/Volo.Abp.TestBase/Volo/Abp/Testing/AbpAsyncIntegratedTest.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Testing;
+
+public class AbpAsyncIntegratedTest<TStartupModule> : AbpTestBaseWithServiceProvider
+    where TStartupModule : IAbpModule
+{
+    protected IAbpApplication Application { get; set; }
+
+    protected IServiceProvider RootServiceProvider { get; set; }
+
+    protected IServiceScope TestServiceScope { get; set; }
+
+    public virtual async Task InitializeAsync()
+    {
+        var services = await CreateServiceCollectionAsync();
+
+        await BeforeAddApplicationAsync(services);
+        var application = await services.AddApplicationAsync<TStartupModule>(await SetAbpApplicationCreationOptionsAsync());
+        await AfterAddApplicationAsync(services);
+
+        RootServiceProvider = await CreateServiceProviderAsync(services);
+        TestServiceScope = RootServiceProvider.CreateScope();
+        await application.InitializeAsync(TestServiceScope.ServiceProvider);
+        ServiceProvider = application.ServiceProvider;
+        Application = application;
+
+        await InitializeServicesAsync();
+    }
+
+    public virtual async Task DisposeAsync()
+    {
+        await Application.ShutdownAsync();
+        TestServiceScope.Dispose();
+        Application.Dispose();
+    }
+
+    protected virtual Task<IServiceCollection> CreateServiceCollectionAsync()
+    {
+        return Task.FromResult<IServiceCollection>(new ServiceCollection());
+    }
+
+    protected virtual Task BeforeAddApplicationAsync(IServiceCollection services)
+    {
+        return Task.CompletedTask;
+    }
+
+    protected virtual Task<Action<AbpApplicationCreationOptions>> SetAbpApplicationCreationOptionsAsync()
+    {
+        return Task.FromResult<Action<AbpApplicationCreationOptions>>(_ => { });
+    }
+
+    protected virtual Task AfterAddApplicationAsync(IServiceCollection services)
+    {
+        return Task.CompletedTask;
+    }
+
+    protected virtual Task<IServiceProvider> CreateServiceProviderAsync(IServiceCollection services)
+    {
+        return Task.FromResult(services.BuildServiceProviderFromFactory());
+    }
+
+    protected virtual Task InitializeServicesAsync()
+    {
+        return Task.CompletedTask;
+    }
+}

framework/src/Volo.Abp.TestBase/Volo/Abp/Testing/AbpIntegratedTest.cs

@@ -9,8 +9,6 @@ public abstract class AbpIntegratedTest<TStartupModule> : AbpTestBaseWithService
 {
     protected IAbpApplication Application { get; }
 
-    protected override IServiceProvider ServiceProvider => Application.ServiceProvider;
-
     protected IServiceProvider RootServiceProvider { get; }
 
     protected IServiceScope TestServiceScope { get; }
@@ -29,6 +27,7 @@ public abstract class AbpIntegratedTest<TStartupModule> : AbpTestBaseWithService
         RootServiceProvider = CreateServiceProvider(services);
         TestServiceScope = RootServiceProvider.CreateScope();
 
+        ServiceProvider = Application.ServiceProvider;
         application.Initialize(TestServiceScope.ServiceProvider);
     }
 

framework/test/Volo.Abp.Autofac.Tests/Volo/Abp/Autofac/Interception/Autofac_Interception_Test.cs

@@ -1,11 +1,13 @@
-using Volo.Abp.DynamicProxy;
+using System;
+using System.Threading.Tasks;
+using Volo.Abp.DynamicProxy;
 
 namespace Volo.Abp.Autofac.Interception;
 
 public class Autofac_Interception_Test : AbpInterceptionTestBase<AutofacTestModule>
 {
-    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    protected override Task<Action<AbpApplicationCreationOptions>> SetAbpApplicationCreationOptionsAsync()
     {
-        options.UseAutofac();
+        return Task.FromResult<Action<AbpApplicationCreationOptions>>(options => options.UseAutofac());
     }
 }

framework/test/Volo.Abp.Core.Tests/Volo/Abp/DynamicProxy/AbpInterceptionTestBase.cs

@@ -7,10 +7,10 @@ using Xunit;
 
 namespace Volo.Abp.DynamicProxy;
 
-public abstract class AbpInterceptionTestBase<TStartupModule> : AbpIntegratedTest<TStartupModule>
+public abstract class AbpInterceptionTestBase<TStartupModule> : AbpAsyncIntegratedTest<TStartupModule>, IAsyncLifetime
     where TStartupModule : IAbpModule
 {
-    protected override void BeforeAddApplication(IServiceCollection services)
+    protected override Task BeforeAddApplicationAsync(IServiceCollection services)
     {
         services.AddTransient<SimpleAsyncInterceptor>();
         services.AddTransient<SimpleAsyncInterceptor2>();
@@ -32,6 +32,8 @@ public abstract class AbpInterceptionTestBase<TStartupModule> : AbpIntegratedTes
                 registration.Interceptors.Add<SimpleResultCacheTestInterceptor>();
             }
         });
+
+        return Task.CompletedTask;
     }
 
     [Fact]