Orchard Core 中运行带程序上下文的单元测试

 public class AppTestBase<TFixture> : IClassFixture<TFixture> where TFixture : class, IApplicationStartupFixture 
 {
        public readonly TFixture Application;

        public AppTestBase(TFixture application)
        {
            this.Application = application;
        }

        protected T GetService<T>() where T : class
        {
            return this.Application.ServiceProvider.GetService<T>();
        }

        protected T GetRequiredService<T>() where T : class
        {
            return this.Application.ServiceProvider.GetRequiredService<T>();
        }


        protected async Task RunInShellScopeAsync(Func<ShellScope, Task> execute)
        {
            var shellContextFactory = GetRequiredService<IShellContextFactory>();
            IShellHost shellHost = GetRequiredService<IShellHost>();
            using (var shell = await shellContextFactory.CreateDefaultShellContext())
            using (var shellScope = shell.CreateScope())
            {
                var httpContextAccessor = shellScope.ServiceProvider.GetService<IHttpContextAccessor>();
                httpContextAccessor.HttpContext = shellScope.ShellContext.CreateHttpContext();
                await shellScope.UsingAsync(execute);
            }
        }

        protected T CreateController<T>(ShellScope shellScope, HttpContext httpContext)
        {
            var controllerActivatorProvider =
                shellScope.ServiceProvider.GetService<IControllerActivatorProvider>();
            var controllerContext = new ControllerContext()
            {
                HttpContext = httpContext,
            };
            var controllerObj = (T) controllerActivatorProvider.CreateActivator(
                    new ControllerActionDescriptor()
                        {ControllerTypeInfo = (TypeInfo) typeof(T),})
                .Invoke(controllerContext);
            return controllerObj;
        }
    }

    settings["DatabaseProvider"] ="SqlConnection";
    settings["ConnectionString"] = "Server=localhost;Database=xxx;User Id=sa;Password=xxxxxxx";
    settings["TablePrefix"] = "xxx";

    
public static class TestShellContextFactoryExtensions
{
    internal static Task<ShellContext> CreateDefaultShellContext(this IShellContextFactory shellContextFactory)
    {
            var settings = new ShellSettings()
            {
                Name = ShellHelper.DefaultShellName,
                State = TenantState.Running
            };
            
        settings["DatabaseProvider"] ="SqlConnection";
        settings["ConnectionString"] = "Server=localhost;Database=xxx;User Id=sa;Password=xxxxxxx";
        settings["TablePrefix"] = "xxx";
    
            return shellContextFactory.CreateDescribedContextAsync(settings, new ShellDescriptor()
            {
                Features = new List<ShellFeature>()
                {
                    new ShellFeature("Application.Default"),
                    new ShellFeature("OrchardCore.Setup"),
                    new ShellFeature("Operational"),
                },
                Parameters = new List<ShellParameter>(),
            });
            // return shellContextFactory.CreateShellContextAsync(settings);
    }

}

    public static HttpContext CreateHttpContext(this ShellContext shell)
    {
        var settings = shell.Settings;

        var context = new DefaultHttpContext();
         
                // set shell.RequestServices to context
        context.RequestServices = shell.ServiceProvider;
        OrchardCore.Modules.HttpContextExtensions.UseShellScopeServices(context);

        var urlHost = settings.RequestUrlHost?.Split('/',
            StringSplitOptions.RemoveEmptyEntries).FirstOrDefault();

        context.Request.Host = new HostString(urlHost ?? "localhost");

        if (!String.IsNullOrWhiteSpace(settings.RequestUrlPrefix))
        {
            context.Request.PathBase = "/" + settings.RequestUrlPrefix;
        }

        context.Request.Path = "/";
        context.Items["IsBackground"] = true;

        context.Features.Set(new ShellContextFeature
        {
            ShellContext = shell,
            OriginalPathBase = String.Empty,
            OriginalPath = "/"
        });

        return context;
    }

    [Fact]
    public async Task InAppRuntimeTest() {
        await RunInShellScopeAsync(async shellScope =>
        {
            var session = shellScope.ServiceProvider.GetService<ISession>();
            Assert.NotNull(session);

            var controllerObj =
                    CreateController<XxxxxController>(shellScope, shellScope.ShellContext.CreateHttpContext());

            var result = await controllerObj.Index(new XxxxModel(){});

            Assert.NotNull(result);
        });
    }