public async Task InitializeAsync()
{
var services = new ServiceCollection();
var configurationBuilder = new ConfigurationBuilder();
services.AddSingleton <IConfiguration>(configurationBuilder.AddJsonFile("appsettings.json").Build());
var builder = new WebHostBuilder()
.UseContentRoot(Directory.GetCurrentDirectory())
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile("appsettings.json");
config.AddEnvironmentVariables();
});
builder.ConfigureLogging((context, loggingBuilder) =>
{
loggingBuilder.AddConsole();
loggingBuilder.AddDebug();
});
builder.UseStartup <TStartup>();
LocalTestServer = new TestServer(builder);
var client = LocalTestServer.CreateClient();
services.AddScoped(p => RestService.For <IMeasureDistanceClient>(client));
services.AddScoped(p => RestService.For <IMeasureDistanceResponse>(client));
ServiceProvider = services.BuildServiceProvider(false);
await Task.CompletedTask;
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", "Development");
_ = Task.Run(async() =>
{
var builder = new WebHostBuilder();
builder.ConfigureServices(services =>
{
var server = new OwinServer();
server.UseOwin(appFunc =>
{
_appFunc = appFunc;
});
services.AddSingleton <IServer>(server);
services.AddMvc();
});
builder.ConfigureLogging(logging =>
{
logging.AddConsole();
});
_host = builder
.UseStartup <Startup>()
.UseContentRoot(Directory.GetCurrentDirectory())
.Build();
await _host.RunAsync();
});
}
/// <summary>
/// Starts the service using the default controller factory.
/// </summary>
/// <param name="port">The port where the server will listen.</param>
private void StartServer <TStartup>(int port)
where TStartup : class
{
Covenant.Requires <ArgumentException>(port == 0 || NetHelper.IsValidPort(port), nameof(port));
var app = new WebHostBuilder()
.UseStartup <TStartup>()
.UseKestrel(
options =>
{
options.Listen(IPAddress.Loopback, port);
});
if (logWriter != null && logLevel != LogLevel.None)
{
app.ConfigureLogging(
(hostingContext, logging) =>
{
logging.AddProvider(new LoggingProvider(logWriter, logLevel));
});
}
hostConfigurator?.Invoke(app);
WebHost = app.Build();
WebHost.Start();
}
/// <summary>
/// Build web host.
/// </summary>
/// <returns>web host.</returns>
private static IWebHost BuildWebHost <T>(string[] args) where T : class
{
var baseRoot = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
Directory.SetCurrentDirectory(baseRoot);
if (IsServiceMode(args))
{
var exePath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
baseRoot = Path.GetDirectoryName(exePath);
}
var config = new ConfigurationBuilder()
.SetBasePath(baseRoot)
.AddJsonFile("appsettings.json", optional: true)
.AddEnvironmentVariables()
.Build();
var url = $"http://*:{config["ServicePort"]}";
var env = config["ASPNETCORE_ENVIRONMENT"] ?? "Development";
Log.Logger = new LoggerConfiguration()
.ReadFrom.Configuration(config)
.CreateLogger();
try
{
Log.Information("Application starting up. ");
Console.WriteLine(baseRoot);
var webHostBuilder = new WebHostBuilder()
.UseKestrel()
.UseUrls(url)
.UseSerilog()
.UseEnvironment(env)
.UseContentRoot(baseRoot)
.UseConfiguration(config);
webHostBuilder.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddSerilog(Log.Logger);
if (env.Equals("Development"))
{
logging.AddConsole();
logging.AddDebug();
}
});
return(webHostBuilder.UseStartup <T>().Build());
}
catch (Exception ex)
{
Log.Fatal(ex, "Application start-up failed");
return(null);
}
finally
{
////Log.CloseAndFlush();
}
}
private static TestServer CreateResourceServer(Action <OpenIddictValidationBuilder> configuration = null)
{
var builder = new WebHostBuilder();
builder.UseEnvironment("Testing");
builder.ConfigureLogging(options => options.AddDebug());
builder.ConfigureServices(services =>
{
services.AddAuthentication();
services.AddOptions();
services.AddDistributedMemoryCache();
services.AddOpenIddict()
.AddValidation(options => configuration?.Invoke(options));
});
builder.Configure(app =>
{
app.UseAuthentication();
app.Run(context => context.ChallengeAsync(OpenIddictValidationDefaults.AuthenticationScheme));
});
return(new TestServer(builder));
}
public void Initialize(string basePath = null, bool enableLogging = false)
{
var builder = new WebHostBuilder();
builder.ConfigureServices(ConfigureServices);
builder.Configure(app =>
{
if (basePath != null)
{
app.Map(basePath, map =>
{
ConfigureApp(map);
});
}
else
{
ConfigureApp(app);
}
});
if (enableLogging)
{
builder.ConfigureLogging((ctx, b) => b.AddConsole());
}
Server = new TestServer(builder);
Handler = Server.CreateHandler();
BrowserClient = new BrowserClient(new BrowserHandler(Handler));
BackChannelClient = new HttpClient(Handler);
}
public TestServer Build()
{
var configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection(Configuration);
var hostBuilder = new WebHostBuilder()
.UseConfiguration(configurationBuilder.Build())
.UseStartup <Startup>();
if (_helper != null)
{
hostBuilder.ConfigureLogging((builder) =>
{
builder.AddProvider(new XunitLoggerProvider(_helper));
builder.SetMinimumLevel(_minimumLevel);
});
}
var server = new TestServer(hostBuilder);
//Ensure that the Database is created, we use the same feature like inside the Startup in case of Env.IsDevelopment (EF-Migrations)
var scopeFactory = server.Host.Services.GetRequiredService <IServiceScopeFactory>();
using (var scope = scopeFactory.CreateScope())
{
scope.ServiceProvider
.GetRequiredService <IContext>()
.Database
.Migrate();
}
return(server);
}
public static void Main(string[] args)
{
var host = new WebHostBuilder();
host.UseKestrel();
host.UseContentRoot(Directory.GetCurrentDirectory());
host.ConfigureAppConfiguration((context, configuration) =>
{
var environment = context.HostingEnvironment;
configuration.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
configuration.AddJsonFile($"appsettings.{environment.EnvironmentName}.json", optional: true, reloadOnChange: true);
configuration.AddJsonFile($"/run/secrets/appsettings_shared.json", optional: true, reloadOnChange: true);
configuration.AddJsonFile($"/run/secrets/appsettings_api.json", optional: true, reloadOnChange: true);
configuration.AddEnvironmentVariables();
});
host.ConfigureLogging((context, logging) =>
{
logging.AddConfiguration(context.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
});
host.UseStartup <Startup>();
host.Build().Run();
}
private static TestServer CreateAuthorizationServer(Action <OpenIddictServerBuilder> configuration = null)
{
var builder = new WebHostBuilder();
builder.UseEnvironment("Testing");
builder.ConfigureLogging(options => options.AddDebug());
builder.ConfigureServices(services =>
{
services.AddAuthentication();
services.AddOptions();
services.AddDistributedMemoryCache();
services.AddOpenIddict()
.AddCore(options =>
{
options.SetDefaultApplicationEntity <OpenIddictApplication>()
.SetDefaultAuthorizationEntity <OpenIddictAuthorization>()
.SetDefaultScopeEntity <OpenIddictScope>()
.SetDefaultTokenEntity <OpenIddictToken>();
})
.AddServer(options => configuration?.Invoke(options));
});
builder.Configure(app =>
{
app.UseAuthentication();
app.Run(context => context.ChallengeAsync(OpenIddictServerDefaults.AuthenticationScheme));
});
return(new TestServer(builder));
}
public static void Main(string[] args)
{
Mapper.RegisterConverter <Model.User, Database.Entities.User>(new UserConverter().ConvertToEntity);
Mapper.RegisterConverter <Database.Entities.User, Model.User>(new UserConverter().ConvertToModel);
var host = new WebHostBuilder();
host.UseKestrel();
host.UseContentRoot(System.IO.Directory.GetCurrentDirectory());
host.ConfigureAppConfiguration((context, configuration) =>
{
var environment = context.HostingEnvironment;
configuration.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
configuration.AddJsonFile($"appsettings.{environment.EnvironmentName}.json", optional: true, reloadOnChange: true);
configuration.AddJsonFile($"/run/secrets/appsettings_shared.json", optional: true, reloadOnChange: true);
configuration.AddJsonFile($"/run/secrets/appsettings_directory.json", optional: true, reloadOnChange: true);
configuration.AddEnvironmentVariables();
});
host.ConfigureLogging((context, logging) =>
{
logging.AddConfiguration(context.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
});
host.UseStartup <Startup>();
host.Build().Run();
}
static void Main(string[] args)
{
var builder = new WebHostBuilder();
builder.UseContentRoot(Directory.GetCurrentDirectory());
builder.UseKestrel((builderContext, options) =>
{
options.Listen(IPAddress.Any, 50500);
});
builder.ConfigureAppConfiguration((hostingContext, config) =>
{
var env = hostingContext.HostingEnvironment;
config.AddEnvironmentVariables();
if (env.IsDevelopment())
{
config.AddUserSecrets <Program>();
}
});
builder.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddConsole();
});
builder.UseStartup <Startup>();
var host = builder.Build();
host.Run();
}
public static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddCommandLine(args)
.AddEnvironmentVariables(prefix: "ASPNETCORE_")
.Build();
var builder = new WebHostBuilder()
.UseConfiguration(config)
.UseIISIntegration()
.UseStartup("MusicStore")
.UseDefaultServiceProvider((context, options) => {
options.ValidateScopes = true;
});
var environment = builder.GetSetting("environment") ??
Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (string.Equals(builder.GetSetting("server"), "Microsoft.AspNetCore.Server.HttpSys", System.StringComparison.Ordinal))
{
if (string.Equals(environment, "NtlmAuthentication", System.StringComparison.Ordinal))
{
// Set up NTLM authentication for WebListener like below.
// For IIS and IISExpress: Use inetmgr to setup NTLM authentication on the application vDir or
// modify the applicationHost.config to enable NTLM.
builder.UseHttpSys(options =>
{
options.Authentication.Schemes = AuthenticationSchemes.NTLM;
options.Authentication.AllowAnonymous = false;
});
}
else
{
builder.UseHttpSys();
}
}
else
{
builder.UseKestrel();
}
// In Proc
builder.UseIIS();
builder.ConfigureLogging(factory =>
{
factory.AddConsole();
var logLevel = string.Equals(environment, "Development", StringComparison.Ordinal) ? LogLevel.Information : LogLevel.Warning;
factory.SetMinimumLevel(logLevel);
// Turn off Info logging for EF commands
factory.AddFilter("Microsoft.EntityFrameworkCore.Database.Command", LogLevel.Warning);
});
var host = builder.Build();
host.Run();
}
public virtual void ConfigureLogging(Microsoft.Extensions.Logging.LogLevel logLevel)
{
WebHostBuilder.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.SetMinimumLevel(logLevel);
});
}
private void ConfigureLogging()
{
_builder.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
});
}
//private void CreateBasic(out )
protected WebHostBuilder CreateDefaultWebHostBuilder()
{
var webHostBuilder = new WebHostBuilder();
webHostBuilder.ConfigureLogging(lb => lb.AddXUnit(outputHelper).AddFilter("RTUITLab", LogLevel.Trace));
webHostBuilder.Configure(app => app.UseWebAppConfigure());
webHostBuilder.ConfigureServices(services => services.AddSingleton <TestValuesStorage>());
return(webHostBuilder);
}
public void ConfigureWebHostBuilder(ExecutionContext executionContext, WebHostBuilder builder)
{
builder.ConfigureAppConfiguration(ConfigureAppConfiguration);
builder.ConfigureLogging(Logging);
if (environment.IsDevelopment())
{
builder.UseContentRoot(Path.Combine(Directory.GetCurrentDirectory(), "../../../../../src/DotNetDevOps.Web"));
}
}
public DefaultWebHostConfiguration ConfigureLogging()
{
_builder.ConfigureLogging((WebHostBuilderContext hostingContext, ILoggingBuilder logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
});
return(this);
}
public static IWebHost BuildWebHost(string[] args)
{
IWebHostBuilder hostBuilder = new WebHostBuilder();
CommandLineArgs commandLine = ReadCommandLine(args);
// Load the config file to read some early startup settings
// Namely, the logging config file path and everything in the Hosting section.
// ASP.NET Core will read the same file again because the rest of the app's settings are there.
IConfigurationBuilder bootstrapConfigBuilder = new ConfigurationBuilder()
.AddXmlFile(commandLine.ConfigFile);
IConfigurationRoot bootstrapRawConfig = bootstrapConfigBuilder.Build();
Config bootstrapConfig = bootstrapRawConfig.Get <Config>();
if (!string.IsNullOrWhiteSpace(bootstrapConfig.LoggingConfigPath))
{
Logging.SetUpLogging(bootstrapConfig.LoggingConfigPath);
hostBuilder.UseNLog();
}
else
{
Console.Error.WriteLine("No logging configuration file set. Logging to console.");
Logging.SetUpConsoleLogging();
hostBuilder.ConfigureLogging((hostingContext, logging) =>
{
logging.SetMinimumLevel(LogLevel.Information);
logging.AddConsole();
});
}
string appDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
hostBuilder
.UseKestrel(options =>
{
if (bootstrapConfig.Hosting.UnixSocketPath != null)
{
options.ListenUnixSocket(bootstrapConfig.Hosting.UnixSocketPath);
}
else
{
options.Listen(IPAddress.Loopback, bootstrapConfig.Hosting.Port);
}
})
.UseContentRoot(Environment.CurrentDirectory)
.ConfigureAppConfiguration((context, configBuilder) =>
{
configBuilder.AddXmlFile(commandLine.ConfigFile, optional: false, reloadOnChange: true);
})
.UseStartup <Startup>();
return(hostBuilder.Build());
}
public static TestApplication BuildTestApplication <TStartup>(TestApplication testApp,
string environmentName = "Production",
Action <IWebHostBuilder> configureHost = null) where TStartup : class
{
testApp.LoggerProvider = new StubLoggerProvider();
testApp.User = new ClaimsPrincipal(new ClaimsIdentity());
var hostBuilder = new WebHostBuilder();
configureHost?.Invoke(hostBuilder);
hostBuilder.ConfigureServices(services =>
{
services.AddTransient <HttpContextFactory>();
services.AddTransient <IHttpContextFactory>((sp) =>
{
var defaultContextFactory = sp.GetService <HttpContextFactory>();
var httpContextFactory = new WrappedHttpContextFactory(defaultContextFactory);
httpContextFactory.ConfigureFeatureWithContext((features, httpCtx) =>
{
features.Set <IHttpAuthenticationFeature>(new HttpAuthenticationFeature {
User = testApp.User
});
features.Set <IServiceProvidersFeature>(new RequestServicesFeature(httpCtx,
testApp.ApplicationServices.GetService <IServiceScopeFactory>()));
});
return(httpContextFactory);
});
});
var connectionStringEVKey = $"DOTNETCLUB_{ServiceExtensions.ConfigKeyConnectionString}";
if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable(connectionStringEVKey)))
{
Environment.SetEnvironmentVariable(connectionStringEVKey, " ");
}
Environment.SetEnvironmentVariable("DOTNETCLUB_Logging:Console:LogLevel:Default", "Warning");
Configuration.ConfigureHost(hostBuilder);
hostBuilder.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.SetMinimumLevel(LogLevel.Trace);
loggingBuilder.AddProvider(testApp.LoggerProvider);
});
hostBuilder
.UseContentRoot(TestEnv.WebProjectPath())
.UseEnvironment(environmentName)
.UseStartup <TStartup>();
testApp.Server = new TestServer(hostBuilder);
testApp.ApplicationServices = testApp.Server.Host.Services;
testApp._spOverrider = new ServiceProviderOverrider(testApp.ApplicationServices);
return(testApp);
}
public async Task Response422IfUpdatingNotSettableAttribute()
{
// Arrange
var builder = new WebHostBuilder().UseStartup <TestStartup>();
var loggerFactory = new FakeLoggerFactory();
builder.ConfigureLogging(options =>
{
options.AddProvider(loggerFactory);
options.SetMinimumLevel(LogLevel.Trace);
options.AddFilter((category, level) => level == LogLevel.Trace &&
(category == typeof(JsonApiReader).FullName || category == typeof(JsonApiWriter).FullName));
});
var server = new TestServer(builder);
var client = server.CreateClient();
var todoItem = _todoItemFaker.Generate();
_context.TodoItems.Add(todoItem);
_context.SaveChanges();
var serializer = TestFixture <TestStartup> .GetSerializer <TodoItem>(server.Host.Services, ti => new { ti.CalculatedValue });
var content = serializer.Serialize(todoItem);
var request = PrepareRequest("PATCH", $"/api/v1/todoItems/{todoItem.Id}", content);
// Act
var response = await client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.UnprocessableEntity, response.StatusCode);
var body = await response.Content.ReadAsStringAsync();
var document = JsonConvert.DeserializeObject <ErrorDocument>(body);
Assert.Single(document.Errors);
var error = document.Errors.Single();
Assert.Equal(HttpStatusCode.UnprocessableEntity, error.StatusCode);
Assert.Equal("Failed to deserialize request body.", error.Title);
Assert.StartsWith("Property 'TodoItem.CalculatedValue' is read-only. - Request body: <<", error.Detail);
Assert.NotEmpty(loggerFactory.Logger.Messages);
Assert.Contains(loggerFactory.Logger.Messages,
x => x.Text.StartsWith("Received request at ") && x.Text.Contains("with body:"));
Assert.Contains(loggerFactory.Logger.Messages,
x => x.Text.StartsWith("Sending 422 response for request at ") && x.Text.Contains("Failed to deserialize request body."));
}
public void ConfigureWebHostBuilder(WebHostBuilder builder)
{
builder.ConfigureAppConfiguration(ConfigureAppConfiguration);
builder.ConfigureLogging(Logging);
if (hostingEnvironment.IsDevelopment())
{
builder.UseContentRoot(Path.Combine(Directory.GetCurrentDirectory(), "../../.."));
}
// builder.UseContentRoot();
// builder.UseContentRoot(Directory.GetCurrentDirectory());
// builder.UseContentRoot();
}
private static void ConfigureLogging(WebHostBuilder builder)
{
builder.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddConsole();
logging.AddDebug();
logging.AddApplicationInsights(azureAppConfig.Global.InstrumentationKey);
logging.SetMinimumLevel(LogLevel.Debug);
// The following configures LogLevel Information or above to be sent to Application Insights for all categories.
logging.AddFilter <ApplicationInsightsLoggerProvider>(string.Empty, LogLevel.Information);
});
}
public static TestApplication BuildTestApplication <TStartup>(TestApplication testApp,
string environmentName = "Production",
Action <IWebHostBuilder> configureHost = null) where TStartup : class
{
testApp.LoggerProvider = new StubLoggerProvider();
testApp.User = new ClaimsPrincipal(new ClaimsIdentity());
var hostBuilder = new WebHostBuilder();
configureHost?.Invoke(hostBuilder);
hostBuilder.ConfigureServices(services =>
{
services.AddTransient <HttpContextFactory>();
services.AddTransient <IHttpContextFactory>((sp) =>
{
var defaultContextFactory = sp.GetService <HttpContextFactory>();
var httpContextFactory = new WrappedHttpContextFactory(defaultContextFactory);
httpContextFactory.ConfigureFeatureWithContext((features, httpCtx) =>
{
features.Set <IHttpAuthenticationFeature>(new HttpAuthenticationFeature {
User = testApp.User
});
features.Set <IServiceProvidersFeature>(new RequestServicesFeature(httpCtx,
testApp.ApplicationServices.GetService <IServiceScopeFactory>()));
});
return(httpContextFactory);
});
});
Environment.SetEnvironmentVariable("SGConnectionString", "Data Source=.;Initial Catalog=siegrain.blog;Integrated Security=True");
WebHostConfiguration.Configure(hostBuilder);
hostBuilder.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.SetMinimumLevel(LogLevel.Trace);
loggingBuilder.AddProvider(testApp.LoggerProvider);
});
hostBuilder
.UseContentRoot(TestEnv.WebProjectPath())
.UseEnvironment(environmentName)
.UseStartup <TStartup>();
testApp.Server = new TestServer(hostBuilder);
testApp.ApplicationServices = testApp.Server.Host.Services;
testApp._spOverrider = new ServiceProviderOverrider(testApp.ApplicationServices);
return(testApp);
}
protected override void ConfigureBuilder(WebHostBuilder builder)
{
Events = new List <SentryEvent>();
Configure = options =>
{
options.BeforeSend = @event =>
{
Events.Add(@event);
LastEvent = @event;
return(@event);
};
};
ConfigureApp = app =>
{
#if NETCOREAPP3_1_OR_GREATER
app.UseExceptionHandler(new ExceptionHandlerOptions
{
#if NET6_0_OR_GREATER
AllowStatusCode404Response = true,
#endif
ExceptionHandlingPath = "/error"
});
#endif
};
var sentry = FakeSentryServer.CreateServer();
var sentryHttpClient = sentry.CreateClient();
_ = builder.UseSentry(options =>
{
options.Dsn = DsnSamples.ValidDsnWithSecret;
options.SentryHttpClientFactory = new DelegateHttpClientFactory(_ => sentryHttpClient);
Configure?.Invoke(options);
});
builder.ConfigureLogging(loggingBuilder =>
{
var logger = new LoggerConfiguration()
.WriteTo.Sentry()
.CreateLogger();
loggingBuilder.AddSerilog(logger);
});
AfterConfigureBuilder?.Invoke(builder);
}
public static TestApplication BuildApplication(TestApplication testApp, string environmentName = "Production", Action <IWebHostBuilder> configureHost = null)
{
testApp.LoggerProvider = new StubLoggerProvider();
testApp.User = new ClaimsPrincipal(new ClaimsIdentity());
var hostBuilder = new WebHostBuilder();
configureHost?.Invoke(hostBuilder);
hostBuilder.ConfigureServices(services =>
{
services.AddTransient <HttpContextFactory>();
services.AddTransient <IHttpContextFactory>((sp) =>
{
var defaultContextFactory = sp.GetService <HttpContextFactory>();
var httpContextFactory = new WrappedHttpContextFactory(defaultContextFactory);
httpContextFactory.ConfigureFeatureWithContext((features, httpCtx) =>
{
features.Set <IHttpAuthenticationFeature>(new HttpAuthenticationFeature {
User = testApp.User
});
features.Set <IServiceProvidersFeature>(new RequestServicesFeature(httpCtx, testApp.ServiceReplacer.CreateScopeFactory()));
});
return(httpContextFactory);
});
});
Environment.SetEnvironmentVariable("DOTNETCLUB_sqliteConnectionString", " ");
Environment.SetEnvironmentVariable("DOTNETCLUB_Logging:Console:LogLevel:Default", "Warning");
Configurer.ConfigureHost(hostBuilder);
hostBuilder.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.SetMinimumLevel(LogLevel.Trace);
loggingBuilder.AddProvider(testApp.LoggerProvider);
});
hostBuilder.UseContentRoot(WebProjectPath()).UseEnvironment(environmentName);
testApp.Server = new TestServer(hostBuilder);
testApp.ApplicationServices = testApp.Server.Host.Services;
testApp.ServiceReplacer = new ReplacableServiceProvider(testApp.ApplicationServices);
return(testApp);
}
public static HttpHandlerBuilder Start(int port, Action <ILoggingBuilder> loggingBuilder = null)
{
var handlerBuilder = new HttpHandlerBuilder();
var webHostBuilder = new WebHostBuilder()
.UseKestrel(k => k.Listen(IPAddress.Any, port))
.Configure(app => Configure(app, handlerBuilder));
if (loggingBuilder != null)
{
webHostBuilder.ConfigureLogging(loggingBuilder);
}
var webHost = webHostBuilder.Build();
handlerBuilder.SetServer(webHost);
webHost.Start();
return(handlerBuilder);
}
public IWebHost BuildHost()
{
// SAMPLE: what-the-cli-is-doing
// The --log-level flag value overrides your application's
// LogLevel
if (LogLevelFlag.HasValue)
{
Console.WriteLine($"Overwriting the minimum log level to {LogLevelFlag.Value}");
WebHostBuilder.ConfigureLogging(x => x.SetMinimumLevel(LogLevelFlag.Value));
}
if (VerboseFlag)
{
Console.WriteLine("Verbose flag is on.");
// The --verbose flag adds console and
// debug logging, as well as setting
// the minimum logging level down to debug
WebHostBuilder.ConfigureLogging(x =>
{
x.SetMinimumLevel(LogLevel.Debug);
});
}
// The --environment flag is used to set the environment
// property on the IHostedEnvironment within your system
if (EnvironmentFlag.IsNotEmpty())
{
Console.WriteLine($"Overwriting the environment to `{EnvironmentFlag}`");
WebHostBuilder.UseEnvironment(EnvironmentFlag);
}
if (ConfigFlag.Any())
{
WebHostBuilder.ConfigureAppConfiguration(c => c.AddInMemoryCollection(ConfigFlag));
}
// ENDSAMPLE
return(WebHostBuilder.Build());
}
public TestServer Build()
{
Dictionary <string, string> testHostConfig = new Dictionary <string, string>();
testHostConfig.Add("Database:Type", "Sqlite");
string resolvedSqliteFile = Path.GetFullPath("..\\..\\baget.db");
testHostConfig.Add("Database:ConnectionString", string.Format("Data Source={0}", resolvedSqliteFile));
testHostConfig.Add("Storage:Type", "FileSystem");
testHostConfig.Add("Mirror:EnableReadThroughCaching", false.ToString());
IConfigurationBuilder configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection(testHostConfig);
IWebHostBuilder hostBuilder = new WebHostBuilder()
.UseConfiguration(configurationBuilder.Build())
.UseStartup <Startup>();
if (_helper != null)
{
hostBuilder.ConfigureLogging((builder) =>
{
builder.AddProvider(new XunitLoggerProvider(_helper));
builder.SetMinimumLevel(_minimumLevel);
});
}
TestServer server = new TestServer(hostBuilder);
//Ensure that the Database is created, we use the same feature like inside the Startup in case of Env.IsDevelopment (EF-Migrations)
var scopeFactory = server.Host.Services.GetRequiredService <IServiceScopeFactory>();
using (var scope = scopeFactory.CreateScope())
{
scope.ServiceProvider
.GetRequiredService <IContext>()
.Database
.Migrate();
}
return(server);
}
public IJasperHost BuildHost(StartMode mode)
{
// SAMPLE: what-the-cli-is-doing
// The --log-level flag value overrides your application's
// LogLevel
if (LogLevelFlag.HasValue)
{
WebHostBuilder.ConfigureLogging(x => x.SetMinimumLevel(LogLevelFlag.Value));
}
if (VerboseFlag)
{
Console.WriteLine("Verbose flag is on.");
// The --verbose flag adds console and
// debug logging, as well as setting
// the minimum logging level down to debug
WebHostBuilder.ConfigureLogging(x =>
{
x.SetMinimumLevel(LogLevel.Debug);
x.AddConsole();
x.AddDebug();
});
}
// The --environment flag is used to set the environment
// property on the IHostedEnvironment within your system
if (EnvironmentFlag.IsNotEmpty())
{
WebHostBuilder.UseEnvironment(EnvironmentFlag);
}
// ENDSAMPLE
return(mode == StartMode.Full ? WebHostBuilder.StartJasper() : new JasperRuntime(WebHostBuilder.Build()));
}
public IWebHostBuilder CreateDefaultBuilder(string[] args)
{
var webHostBuilder = new WebHostBuilder();
webHostBuilder.UseKestrel();
webHostBuilder.UseContentRoot(Directory.GetCurrentDirectory());
webHostBuilder.ConfigureAppConfiguration((hostingContext, config) =>
{
IHostingEnvironment hostingEnvironment = hostingContext.HostingEnvironment;
config.AddJsonFile("appsettings.json", true, true).AddJsonFile(string.Format("appsettings.{0}.json", (object)hostingEnvironment.EnvironmentName), true, true);
if (hostingEnvironment.IsDevelopment())
{
Assembly assembly = Assembly.Load(new AssemblyName(hostingEnvironment.ApplicationName));
if (assembly != null)
config.AddUserSecrets(assembly, true);
}
config.AddEnvironmentVariables();
if (args == null)
return;
config.AddCommandLine(args);
});
webHostBuilder.ConfigureLogging((hostingContext, logging) =>
{
logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
logging.AddConsole();
logging.AddDebug();
});
if (_withIisIntegration)
{
webHostBuilder.UseIISIntegration();
}
webHostBuilder.UseDefaultServiceProvider((context, options) => options.ValidateScopes = context.HostingEnvironment.IsDevelopment());
return webHostBuilder;
}
