private static TestServer CreateAuthorizationServer(Action <OpenIdConnectServerOptions> configuration = null) { var builder = new WebHostBuilder(); builder.UseEnvironment("Testing"); builder.ConfigureServices(services => services.AddAuthentication()); builder.Configure(app => { app.UseOpenIdConnectServer(options => { options.AllowInsecureHttp = true; options.SigningCredentials.AddCertificate( assembly: typeof(OpenIdConnectServerMiddlewareTests).GetTypeInfo().Assembly, resource: "AspNet.Security.OpenIdConnect.Server.Tests.Certificate.pfx", password: "******"); // Note: overriding the default data protection provider is not necessary for the tests to pass, // but is useful to ensure unnecessary keys are not persisted in testing environments, which also // helps make the unit tests run faster, as no registry or disk access is required in this case. options.DataProtectionProvider = new EphemeralDataProtectionProvider(app.ApplicationServices); // Run the configuration delegate // registered by the unit tests. configuration?.Invoke(options); }); }); return(new TestServer(builder)); }
public UsersResourceSampleSite(string resource) { var webhostbuilder = new WebHostBuilder(); webhostbuilder .ConfigureServices(services => { services.AddSingleton(_ => new State()); services.AddSingleton(_ => new MapperConfiguration(cfg => { cfg.CreateMap <UserUpdateRequest, UserResponse>(); cfg.CreateMap <UserCreateRequest, UserResponse>(); }).CreateMapper()); services.AddRouting(); services.AddMemoryCache(); }) .Configure(app => { app.UseRouter(MatchesRequest); }); _server = new TestServer(webhostbuilder); _client = _server.CreateClient(); RefreshClient(resource); }
public void Initialize(string basePath = null) { var builder = new WebHostBuilder(); builder.ConfigureServices(ConfigureServices); builder.Configure(app => { if (basePath != null) { app.Map(basePath, map => { ConfigureApp(map); }); } else { ConfigureApp(app); } }); var server = new TestServer(builder); Server = new TestServer(builder); Handler = Server.CreateHandler(); BrowserClient = new BrowserClient(new BrowserHandler(Handler)); Client = new HttpClient(Handler); }
protected static TestServer SetupSample( IEnumerable <User> testdata = null, Action <WebHostBuilder> setup = null ) { var databaseName = "Blog_" + Guid.NewGuid(); var builder = new WebHostBuilder(); builder.UseStartup <Startup>(); builder.ConfigureServices(s => { s.AddDbContext <BlogDbContext>(o => o.UseInMemoryDatabase(databaseName)); }); setup?.Invoke(builder); var server = new TestServer(builder); if (testdata != null) { using (var scope = server.Services.CreateScope()) { var context = scope.ServiceProvider.GetRequiredService <BlogDbContext>(); context.Database.EnsureCreated(); context.Users.AddRange(testdata); context.SaveChanges(); } } return(server); }
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 static WebHostBuilder UseProjectOf <TStartup>(this WebHostBuilder builder) { var applicationName = typeof(TStartup).GetTypeInfo().Assembly.GetName().Name; var webRoot = GetProjectDirectoryOf <TStartup>(); var assemblyProvider = new StaticAssemblyProvider(); assemblyProvider.CandidateAssemblies.Add(typeof(TStartup).Assembly); builder.ConfigureServices(services => { var applicationEnvironment = new TestApplicationEnvironment( PlatformServices.Default.Application, applicationName, webRoot); services.AddSingleton <IApplicationEnvironment>(applicationEnvironment); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize( webRoot, new WebHostOptions { Environment = "Production", }, configuration: null); services.AddSingleton <IHostingEnvironment>(hostingEnvironment); services.AddSingleton <IAssemblyProvider>(assemblyProvider); }); return(builder); }
public IWebHostBuilder ConfigureServices(Action <WebHostBuilderContext, IServiceCollection> configureServices) { WebHostBuilder.ConfigureServices(configureServices); MockLogger = new MockLogger(); WebHostBuilder.ConfigureServices(x => x.Replace(new ServiceDescriptor(typeof(ILoggerFactory), new MockLoggerFactory(_ => MockLogger)))); return(this); }
public override void SetUp() { theCheck = new RecordingEnvironmentCheck(); var builder = new WebHostBuilder(); builder.UseUrls("http://localhost:3456"); //builder.UseKestrel(); builder.ConfigureServices(x => { x.AddSingleton <IService, Service>(); x.AddSingleton <IEnvironmentCheck>(theCheck); }); builder.ConfigureAppConfiguration(b => { b.AddInMemoryCollection(new Dictionary <string, string> { { "city", "Austin" } }); }); builder.UseStartup <AppStartUp>(); builder.UseEnvironment("Green"); builder.UseJasper <BootstrappingApp>(); theSystem = new SystemUnderTest(builder); theContainer = theSystem.Services.As <IContainer>(); }
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 int Server() { BuildSite(Site, true); try { var wwwDirectory = Site.OutputFileSystem.ConvertPathToInternal(UPath.Root); var hostBuilder = new WebHostBuilder() .UseKestrel() .UseWebRoot(wwwDirectory) .UseContentRoot(wwwDirectory) .UseUrls(Site.BaseUrl) .Configure(Configure); // Setup the environment // TODO: access to Site.Scripts.SiteFunctions.LunetObject is too long! hostBuilder.UseEnvironment(Site.Scripts.SiteFunctions.LunetObject.Environment ?? "Development"); // Enable server log only if log.server = true if (Site.Scripts.SiteFunctions.LogObject.GetSafeValue <bool>("server")) { hostBuilder.ConfigureServices(collection => collection.Add(ServiceDescriptor.Singleton(Site.LoggerFactory))); } var host = hostBuilder.Build(); host.Run(); } catch (Exception ex) { Site.Error($"Error while starting server. Reason: {ex.GetReason()}"); return(1); } return(0); }
public void SetRegistryProvider(IAssetAdministrationShellRegistry aasRegistryProvider) { WebHostBuilder.ConfigureServices(services => { services.AddSingleton <IAssetAdministrationShellRegistry>(aasRegistryProvider); }); }
public async void Should_serve_hal_endpoints() { var streamStore = new InMemoryStreamStore(); var builder = new WebHostBuilder(); builder.ConfigureServices(services => services .AddSingleton <IStartup>(new TestStartup(streamStore))); var server = new TestServer(builder); var client = server.CreateClient(); var request = new HttpRequestMessage() { RequestUri = new Uri("http://localhost/hal"), Method = HttpMethod.Get, }; request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/hal+json")); var halResponse = await client.SendAsync(request); var content = await halResponse.Content.ReadAsStringAsync(); Assert.Equal(HttpStatusCode.OK, halResponse.StatusCode); Assert.Contains("provider", content); Assert.Contains("InMemory", content); }
public static void Main(string[] args) { var configurationBuilder = new Microsoft.Extensions.Configuration.ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddJsonFile("appsettings.Development.json", true, false) .AddJsonFile("appsettings.Production.json", true, false) .AddEnvironmentVariables() .AddCommandLine(args); if (args != null) { configurationBuilder.AddCommandLine(args); } var hostingconfig = configurationBuilder.Build(); var url = hostingconfig[addressKey] ?? defaultAddress; IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { s.AddSingleton(builder); }); builder.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseConfiguration(hostingconfig) .UseIISIntegration() .UseUrls(url) .UseStartup <Startup>(); var host = builder.Build(); host.Run(); }
private string Start(string assemblyName) { var builder = new WebHostBuilder() .UseContentRoot(Directory.GetCurrentDirectory()) .UseUrls(this.BaseHost) .UseKestrel() .UseStartup(assemblyName) .UseEnvironment("Production"); builder.ConfigureServices(services => { services.AddSingleton <IApplicationIdProvider>(provider => new DictionaryApplicationIdProvider() { Defined = new Dictionary <string, string> { [IKey] = AppId } }); }); if (this.configureHost != null) { builder = this.configureHost(builder); } this.hostingEngine = builder.Build(); this.hostingEngine.Start(); this.ApplicationServices = this.hostingEngine.Services; return(((EndpointAddress)this.hostingEngine.Services.GetService <EndpointAddress>()).ConnectionString); }
private static TestServer CreateAuthorizationServer(Action <OpenIdConnectServerOptions> configuration = null) { var builder = new WebHostBuilder(); builder.UseEnvironment("Testing"); builder.ConfigureServices(services => services.AddAuthentication()); builder.Configure(app => { app.UseOpenIdConnectServer(options => { options.AllowInsecureHttp = true; // Note: overriding the default data protection provider is not necessary for the tests to pass, // but is useful to ensure unnecessary keys are not persisted in testing environments, which also // helps make the unit tests run faster, as no registry or disk access is required in this case. options.DataProtectionProvider = new EphemeralDataProtectionProvider(app.ApplicationServices); // Run the configuration delegate // registered by the unit tests. configuration?.Invoke(options); }); }); return(new TestServer(builder)); }
public void SetServiceProvider(IAssetAdministrationShellServiceProvider aasServiceProvider) { WebHostBuilder.ConfigureServices(services => { services.AddSingleton <IAssetAdministrationShellServiceProvider>(aasServiceProvider); }); }
public static void Main(string[] args) { IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { s.AddSingleton(builder); }); builder .UseKestrel() .UseUrls("http://*:4999") .UseContentRoot(Directory.GetCurrentDirectory()) .ConfigureAppConfiguration((hostingContext, config) => { config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath); var env = hostingContext.HostingEnvironment; config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); config.AddJsonFile("configuration.json"); config.AddEnvironmentVariables(); }) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); }) .UseStartup <Startup>(); var host = builder.Build(); host.Run(); }
public async Task GetException_WhenDeveloperPageIsConfigured_ShouldBeInternalServerError() { // Arrange var builder = new WebHostBuilder(); builder.ConfigureServices(services => { services.AddRouting(); }); builder.Configure(app => app .UseDeveloperExceptionPage() .UseRouting() .UseEndpoints(endpoints => { endpoints.Map("/exception", context => { throw new Exception("Wow!", new Exception("Exactly!")); }); })); using var testServer = new TestServer(builder); using var client = testServer.CreateClient(); // Act using var response = await client.GetAsync("/exception"); // Assert response.Should().Be500InternalServerError(); }
public static WebHostBuilder UseProjectOf <TStartup>(this WebHostBuilder builder) { var startupAssembly = typeof(TStartup).GetTypeInfo().Assembly; var applicationName = startupAssembly.GetName().Name; var webRoot = GetProjectDirectoryOf(startupAssembly); builder.ConfigureServices(services => { var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize( applicationName, webRoot, new WebHostOptions { Environment = "Production" }); services.AddSingleton <IHostingEnvironment>(hostingEnvironment); var manager = new ApplicationPartManager(); manager.ApplicationParts.Add(new AssemblyPart(startupAssembly)); services.AddSingleton(manager); }); return(builder); }
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 async Task StartFakeOcelotWithWebSockets() { _ocelotBuilder = new WebHostBuilder(); _ocelotBuilder.ConfigureServices(s => { s.AddSingleton(_ocelotBuilder); s.AddOcelot(); }); _ocelotBuilder.UseKestrel() .UseUrls("http://localhost:5000") .UseContentRoot(Directory.GetCurrentDirectory()) .ConfigureAppConfiguration((hostingContext, config) => { config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath); var env = hostingContext.HostingEnvironment; config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false); config.AddJsonFile("ocelot.json", false, false); config.AddEnvironmentVariables(); }) .ConfigureLogging((hostingContext, logging) => { logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); logging.AddConsole(); }) .Configure(app => { app.UseWebSockets(); app.UseOcelot().Wait(); }) .UseIISIntegration(); _ocelotHost = _ocelotBuilder.Build(); await _ocelotHost.StartAsync(); }
static async Task Main() { var webHostBuilder = new WebHostBuilder(); webHostBuilder.UseKestrel(); webHostBuilder.UseContentRoot(Directory.GetCurrentDirectory()); #region ServiceProviderFactoryAutofac webHostBuilder.ConfigureServices(services => services.AddAutofac()); #endregion webHostBuilder.UseStartup <Startup>(); var host = webHostBuilder.Build(); await host.StartAsync() .ConfigureAwait(false); var serverAddresses = host.ServerFeatures.Get <IServerAddressesFeature>(); var address = serverAddresses.Addresses.First(); Console.WriteLine($"Now listening on: {address}"); Console.WriteLine("Press any key to shutdown"); AttemptToLaunchBrowser(address); Console.ReadKey(); await host.StopAsync() .ConfigureAwait(false); }
public TicketResourceSampleSite(string resource) { var webhostbuilder = new WebHostBuilder(); webhostbuilder .ConfigureServices(services => { services.AddSingleton(_ => new State()); services.AddSingleton(_ => new MapperConfiguration(cfg => { cfg.CreateMap <TicketCreateRequest, TicketResponse>() .ForMember(r => r.Ticket, r => r.MapFrom(req => req)); cfg.CreateMap <TicketUpdateRequest, TicketResponse>() .ForMember(r => r.Ticket, r => r.MapFrom(req => req)); cfg.CreateMap <TicketCreateRequest, Ticket>(); cfg.CreateMap <TicketUpdateRequest, Ticket>(); }).CreateMapper()); services.AddRouting(); services.AddMemoryCache(); }) .Configure(app => { app.UseRouter(MatchesRequest); }); _server = new TestServer(webhostbuilder); RefreshClient(resource); }
public void SetServiceProvider(ISubmodelRepositoryServiceProvider submodelRepositoryServiceProvider) { WebHostBuilder.ConfigureServices(services => { services.AddSingleton <ISubmodelRepositoryServiceProvider>(submodelRepositoryServiceProvider); }); }
/// <summary> /// 应用程序入口点 /// </summary> /// <param name="args">入口点参数</param> public static void Main(string[] args) { IWebHostBuilder builder = new WebHostBuilder(); builder.ConfigureServices(s => { s.AddSingleton(builder); }); // 默认配置 var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) .AddCommandLine(args) // 添加对命令参数的支持 .AddEnvironmentVariables() // 添加环境变量 .Build(); builder.UseKestrel() .UseContentRoot(Directory.GetCurrentDirectory()) .UseIISIntegration() .UseStartup <Startup>() .UseConfiguration(config) .Build() .Run(); }
public async Task TestExceptionLogger() { var hostBuilder = new WebHostBuilder(); hostBuilder .ConfigureServices(collection => { collection.AddSidExceptionHandler(); }) .Configure(app => { var options = new ExceptionHandlerOptions { ClientExceptionEnabled = true }; app.UseSidExceptionHandler(options); }); using (var testServer = new TestServer(hostBuilder)) { var response = await testServer.CreateRequest("/exception/client").GetAsync(); Assert.Equal(400, (int)response.StatusCode); response = await testServer.CreateRequest("/exception/client").PostAsync(); Assert.True(response.IsSuccessStatusCode); } }
public TestFixture() { var builder = new WebHostBuilder() .UseEnvironment("Testing") .UseStartup <CleanArchitecture.Web.Startup>(); builder.ConfigureServices(services => { // Create a new service provider. var serviceProvider = new ServiceCollection() .AddEntityFrameworkInMemoryDatabase() .BuildServiceProvider(); // Add a database context (ApplicationDbContext) using an in-memory // database for testing. services.AddDbContext <NorthwindDbContext>(options => { options.UseInMemoryDatabase("InMemoryDbForTesting"); options.UseInternalServiceProvider(serviceProvider); }); }); var server = new TestServer(builder); Context = server.Host.Services.GetService(typeof(NorthwindDbContext)) as NorthwindDbContext; Client = server.CreateClient(); NorthwindInitializer.Initialize(Context); Context.SaveChanges(); }
public void Background() { "Server is running".x(() => { var serverHostBuilder = new WebHostBuilder(); serverHostBuilder .ConfigureServices(s => s .AddSingleton(new UserStoryEditor())) .UseStartup <Startup>(); this.server = new TestServer(serverHostBuilder); }) .Teardown(() => { this.server.Dispose(); }); "client is connected to server".x(() => { var httpClient = this.server.CreateClient(); httpClient.BaseAddress = new Uri("http://localhost/api/"); this.Client = new WebsiteHttpClient( httpClient); }) .Teardown(() => { this.Client.Dispose(); }); }
public static IWebHost BuildWebHost(string[] args) { var startUrl = new ConfigurationBuilder().AddCommandLine(args).Build(); string url = string.Empty; if (startUrl != null && !string.IsNullOrEmpty(startUrl["scheme"])) { url = $"{startUrl["scheme"]}://{startUrl["ip"]}:{startUrl["port"]}"; } IWebHostBuilder builder = new WebHostBuilder(); //注入WebHostBuilder return(builder.ConfigureServices(service => { service.AddSingleton(builder); }) //加载configuration配置文人年 .ConfigureAppConfiguration(conbuilder => { conbuilder.AddJsonFile("appsettings.json"); conbuilder.AddJsonFile("ocelot.json"); }) .UseKestrel() .UseUrls(string.IsNullOrEmpty(url) ? "http://*:5000" : url) .UseStartup <Startup>() .Build()); }
public void CreateServerAndClient() { IWebHostBuilder webhostBuilder = new WebHostBuilder(); webhostBuilder.ConfigureServices(InitialServiceConfiguration); webhostBuilder = webhostBuilder.UseContentRoot("..\\..\\..\\..\\..\\netmockery").UseStartup <Startup>(); server = new TestServer(webhostBuilder); client = server.CreateClient(); }