internal static StartupMethodsMultitenant <TTenant> LoadMethods <TTenant>(IServiceProvider hostingServiceProvider, Type startupType, string environmentName)
{
StartupMethods methods = StartupLoader.LoadMethods(hostingServiceProvider, startupType, environmentName);
ConfigureMultitenantServicesBuilder <TTenant> servicesMethosPerTenant = FindConfigurePerTenantServicesDelegate <TTenant>(startupType, null, environmentName);
return(new StartupMethodsMultitenant <TTenant>(methods, servicesMethosPerTenant.Build(methods.StartupInstance)));
}
public SelenuimSampleTests()
{
this.tokenSource = new CancellationTokenSource();
string projectName = typeof(Web.Startup).Assembly.GetName().Name;
string currentDirectory = Directory.GetCurrentDirectory();
string webProjectDirectory = Path.GetFullPath(Path.Combine(currentDirectory, $@"..\..\..\..\{projectName}"));
IWebHost webHost = WebHost.CreateDefaultBuilder(new string[0])
.UseSetting(WebHostDefaults.ApplicationKey, projectName)
.UseContentRoot(webProjectDirectory) // This will make appsettings.json to work.
.ConfigureServices(services =>
{
services.AddSingleton(typeof(IStartup), serviceProvider =>
{
IHostingEnvironment hostingEnvironment = serviceProvider.GetRequiredService <IHostingEnvironment>();
StartupMethods startupMethods = StartupLoader.LoadMethods(
serviceProvider,
typeof(TestStartup),
hostingEnvironment.EnvironmentName);
return(new ConventionBasedStartup(startupMethods));
});
})
.UseEnvironment(EnvironmentName.Development)
.UseUrls(TestLocalHostUrl)
//// .UseStartup<Web.TestStartUp>() // It's not working
.Build();
webHost.RunAsync(this.tokenSource.Token);
}
private static void PrepareApplicationAndRoutes(StartupMethods startupMethods)
{
var applicationBuilder = new MockedApplicationBuilder(serviceProvider);
startupMethods?.ConfigureDelegate?.Invoke(applicationBuilder);
AdditionalApplicationConfiguration?.Invoke(applicationBuilder);
var routeBuilder = new RouteBuilder(applicationBuilder)
{
DefaultHandler = new RouteHandler(NullHandler)
};
for (int i = 0; i < applicationBuilder.Routes.Count; i++)
{
var route = applicationBuilder.Routes[i];
routeBuilder.Routes.Add(route);
}
AdditionalRoutes?.Invoke(routeBuilder);
if (StartupType == null || routeBuilder.Routes.Count == 0)
{
routeBuilder.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
routeBuilder.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(serviceProvider));
}
router = routeBuilder.Build();
}
public HisarConventionBasedStartup(StartupMethods methods, Type startupType, IServiceProvider sp)
: base(methods)
{
_sp = sp;
_startupType = startupType;
_configureRoutes = StartupTypeLoader.GetConfigureRoutesMethod(_startupType);
ConfigureRoutesDelegate = routes => ConfigureRoutes(routes);
}
public StartupMethodsMultitenant(StartupMethods methods, Action <IServiceCollection, TTenant> configurePerTenantServices)
: this(
methods.StartupInstance,
methods.ConfigureDelegate,
methods.ConfigureServicesDelegate,
configurePerTenantServices)
{
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
StartupMethods.IssueFines();
}
public WebHostBuilder UseStartup(Action <IApplicationBuilder> configureApp, Func <IServiceCollection, IServiceProvider> configureServices)
{
if (configureApp == null)
{
throw new ArgumentNullException(nameof(configureApp));
}
_startup = new StartupMethods(configureApp, configureServices);
return(this);
}
private StartupMethods SetStartupMethods(IServiceProvider services)
{
if (methods == null && inner != null)
{
methods = StartupLoader.LoadMethods(
services,
inner,
services.GetRequiredService <IHostingEnvironment>().EnvironmentName);
}
return(methods);
}
public WebHostBuilder UseStartup([NotNull] Action <IApplicationBuilder> configureApp, Action <IServiceCollection> configureServices)
{
_startup = new StartupMethods(configureApp,
services =>
{
if (configureServices != null)
{
configureServices(services);
}
return(services.BuildServiceProvider());
});
return(this);
}
public static TestApplicationContext BuildApplication(Action <IConfigurationBuilder> customConfiguration, Action <IServiceCollection> serviceConfiguration, Action <IApplicationBuilder, IHostingEnvironment, ILoggerFactory> serviceCustomConfiguration, string environmentName = "Production")
{
StartupMethods startup = null;
IApplicationBuilder bootingupApp = null;
var bootstrapDiagnosticMessages = new List <string>();
var testApp = new TestApplicationContext
{
LoggerFactory = new StubLoggerFactory(),
ApplicationEnvironment = CreateApplicationEnvironment(),
HostingEnvironment = new HostingEnvironment {
EnvironmentName = environmentName
}
};
testApp.Configuration = BuildConfiguration(testApp.HostingEnvironment, testApp.ApplicationEnvironment, customConfiguration);
Func <IServiceCollection, IServiceProvider> configureServices = services =>
{
services.AddInstance <ILoggerFactory>(testApp.LoggerFactory);
services.AddInstance <IApplicationEnvironment>(testApp.ApplicationEnvironment);
var loader = new StartupLoader(services.BuildServiceProvider(), testApp.HostingEnvironment);
startup = loader.LoadMethods(typeof(Startup), bootstrapDiagnosticMessages);
startup.ConfigureServicesDelegate(services);
serviceConfiguration(services);
testApp.ApplicationServices = services.BuildServiceProvider();
return(testApp.ApplicationServices);
};
Action <IApplicationBuilder> configure = app =>
{
bootingupApp = app;
startup.ConfigureDelegate(app);
serviceCustomConfiguration(app, testApp.HostingEnvironment, testApp.ApplicationServices.GetService <ILoggerFactory>());
};
var webHostBuilder = TestServer
.CreateBuilder(testApp.Configuration)
.UseEnvironment(environmentName)
.UseStartup(configure, configureServices);
testApp.Server = new TestServer(webHostBuilder);
testApp.RequestHandler = bootingupApp.Build();
return(testApp);
}
private static void PrepareServices(IServiceCollection serviceCollection, StartupMethods startupMethods)
{
if (startupMethods?.ConfigureServicesDelegate != null)
{
startupMethods.ConfigureServicesDelegate(serviceCollection);
}
else
{
var defaultRegistrationPlugin = DefaultRegistrationPlugins
.OrderByDescending(p => p.Priority)
.FirstOrDefault();
if (defaultRegistrationPlugin != null)
{
defaultRegistrationPlugin.DefaultServiceRegistrationDelegate(serviceCollection);
}
else
{
serviceCollection
.AddMvcCore()
.AddFormatterMappings()
.AddJsonFormatters();
}
}
AdditionalServices?.Invoke(serviceCollection);
// custom MVC options
serviceCollection.Configure <MvcOptions>(options =>
{
// add controller conventions to save all valid controller types
options.Conventions.Add(new ValidControllersCache());
// string input formatter helps with HTTP request processing
var inputFormatters = options.InputFormatters.OfType <TextInputFormatter>();
if (!inputFormatters.Any(f => f.SupportedMediaTypes.Contains(ContentType.TextPlain)))
{
options.InputFormatters.Add(new StringInputFormatter());
}
});
TryReplaceKnownServices(serviceCollection);
PrepareRouteServices(serviceCollection);
serviceProvider = serviceCollection.BuildServiceProvider();
// this call prepares all application conventions and fills the controller action descriptor cache
serviceProvider.GetService <IControllerActionDescriptorCache>();
}
private static void PrepareServices(IServiceCollection serviceCollection, StartupMethods startupMethods)
{
if (startupMethods?.ConfigureServicesDelegate != null)
{
startupMethods.ConfigureServicesDelegate(serviceCollection);
}
else
{
var defaultRegistrationPlugin = DefaultRegistrationPlugins
.OrderByDescending(p => p.Priority)
.FirstOrDefault();
if (defaultRegistrationPlugin != null)
{
defaultRegistrationPlugin.DefaultServiceRegistrationDelegate(serviceCollection);
}
else
{
serviceCollection.AddMvcCore();
}
}
AdditionalServices?.Invoke(serviceCollection);
TryReplaceKnownServices(serviceCollection);
PrepareRoutingServices(serviceCollection);
#if NET451
var baseStartupType = StartupType;
while (baseStartupType != null && baseStartupType?.BaseType != typeof(object))
{
baseStartupType = baseStartupType.BaseType;
}
var applicationPartManager = (ApplicationPartManager)serviceCollection
.FirstOrDefault(t => t.ServiceType == typeof(ApplicationPartManager))
?.ImplementationInstance;
if (applicationPartManager != null && baseStartupType != null)
{
applicationPartManager.ApplicationParts.Add(new AssemblyPart(baseStartupType.GetTypeInfo().Assembly));
}
#endif
serviceProvider = serviceCollection.BuildServiceProvider();
InitializationPlugins.ForEach(plugin => plugin.InitializationDelegate(serviceProvider));
}
public DelegatedStatelessWebServiceStartup(
IServiceProvider provider,
IHostingEnvironment env,
Action <IServiceCollection> configureServices)
{
_configureServices = configureServices;
if (typeof(TStartup).IsAssignableTo <IStartup>())
{
_startupImplementation = (IStartup)ActivatorUtilities.CreateInstance <TStartup>(provider);
}
else
{
StartupMethods methods = StartupLoader.LoadMethods(provider, typeof(TStartup), env.EnvironmentName);
_startupImplementation = new ConventionBasedStartup(methods);
}
}
public WebHostBuilder UseStartup(Action <IApplicationBuilder> configureApp, Action <IServiceCollection> configureServices)
{
if (configureApp == null)
{
throw new ArgumentNullException(nameof(configureApp));
}
_startup = new StartupMethods(configureApp,
services =>
{
if (configureServices != null)
{
configureServices(services);
}
return(services.BuildServiceProvider());
});
return(this);
}
private static void Initialize()
{
var serviceCollection = GetInitialServiceCollection();
StartupMethods startupMethods = null;
if (StartupType != null)
{
startupMethods = serviceCollection
.BuildServiceProvider()
.GetRequiredService <IStartupLoader>()
.LoadMethods(StartupType, null);
}
PrepareServices(serviceCollection, startupMethods);
PrepareApplicationAndRoutes(startupMethods);
initialiazed = true;
}
private static StartupMethods PrepareStartup(IServiceCollection serviceCollection)
{
StartupMethods startupMethods = null;
if (StartupType != null)
{
startupMethods = StartupLoader.LoadMethods(
serviceCollection.BuildServiceProvider(),
StartupType,
Environment.EnvironmentName);
if (typeof(IStartup).GetTypeInfo().IsAssignableFrom(StartupType.GetTypeInfo()))
{
serviceCollection.AddSingleton(typeof(IStartup), StartupType);
}
else
{
serviceCollection.AddSingleton(typeof(IStartup), sp => new ConventionBasedStartup(startupMethods));
}
}
return(startupMethods);
}
public ConventionBasedStartup(StartupMethods methods)
{
_methods = methods;
}
public WebHostBuilder UseStartup([NotNull] Action <IApplicationBuilder> configureApp, Func <IServiceCollection, IServiceProvider> configureServices)
{
_startup = new StartupMethods(configureApp, configureServices);
return(this);
}
/// <summary>
/// Specify the assembly containing the startup type to be used by the console application
/// </summary>
/// <typeparam name="T"></typeparam>
public ConsoleApplicationBuilder UseStartup <T>()
{
//TODO setup environment names
StartupMethods = StartupLoader.LoadMethods(ServiceProvider, typeof(T), "");
return(this);
}
public TestHostStartupWrapper(TestHost <TStartup> testHost, StartupMethods startupMethods)
{
_testHost = testHost;
_startupMethods = startupMethods;
}
