public void ConfigureConfigServerClientSettingsOptions_WithDefaults() { // Arrange var services = new ServiceCollection().AddOptions(); var environment = new HostingEnvironment(); // Act and Assert var builder = new ConfigurationBuilder().AddConfigServer(environment); var config = builder.Build(); services.Configure<ConfigServerClientSettingsOptions>(config); var service = services.BuildServiceProvider().GetService<IOptions<ConfigServerClientSettingsOptions>>(); Assert.NotNull(service); var options = service.Value; Assert.NotNull(options); ConfigServerTestHelpers.VerifyDefaults(options.Settings); Assert.Equal(ConfigServerClientSettings.DEFAULT_PROVIDER_ENABLED, options.Enabled); Assert.Equal(ConfigServerClientSettings.DEFAULT_FAILFAST, options.FailFast); Assert.Equal(ConfigServerClientSettings.DEFAULT_URI, options.Uri); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, options.Environment); Assert.Equal(ConfigServerClientSettings.DEFAULT_CERTIFICATE_VALIDATION, options.ValidateCertificates); Assert.Null(options.Name); Assert.Null(options.Label); Assert.Null(options.Username); Assert.Null(options.Password); }
public void SpringCloudConfigServer_ReturnsExpectedDefaultData() { // Arrange var appsettings = @" { 'spring': { 'application': { 'name' : 'foo' }, 'cloud': { 'config': { 'uri': 'http://localhost:8888', 'env': 'development' } } } }"; var path = ConfigServerTestHelpers.CreateTempFile(appsettings); var configurationBuilder = new ConfigurationBuilder(); var hostingEnv = new HostingEnvironment(); configurationBuilder.AddJsonFile(path); // Act and Assert (expects Spring Cloud Config server to be running) configurationBuilder.AddConfigServer(hostingEnv); IConfigurationRoot root = configurationBuilder.Build(); Assert.Equal("spam", root["bar"]); Assert.Equal("bar", root["foo"]); Assert.Equal("Spring Cloud Samples", root["info:description"]); Assert.Equal("https://github.com/spring-cloud-samples", root["info:url"]); Assert.Equal("http://localhost:8761/eureka/", root["eureka:client:serviceUrl:defaultZone"]); }
public ActivityApiControllerTest() { if (_serviceProvider == null) { var services = new ServiceCollection(); // Add Configuration to the Container var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddEnvironmentVariables(); IConfiguration configuration = builder.Build(); services.AddSingleton(x => configuration); // Add EF (Full DB, not In-Memory) services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); // Setup hosting environment IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); _serviceProvider = services.BuildServiceProvider(); } }
public TestBase() { if (ServiceProvider == null) { var services = new ServiceCollection(); // set up empty in-memory test db services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); // add identity service services.AddIdentity<ApplicationUser, IdentityRole>() .AddEntityFrameworkStores<AllReadyContext>(); var context = new DefaultHttpContext(); context.Features.Set<IHttpAuthenticationFeature>(new HttpAuthenticationFeature()); services.AddSingleton<IHttpContextAccessor>(h => new HttpContextAccessor { HttpContext = context }); // Setup hosting environment IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); // set up service provider for tests ServiceProvider = services.BuildServiceProvider(); } }
public void AddConfigServer_ThrowsIfConfigBuilderNull() { // Arrange IConfigurationBuilder configurationBuilder = null; var environment = new HostingEnvironment(); // Act and Assert var ex = Assert.Throws<ArgumentNullException>(() => ConfigServerConfigurationExtensions.AddConfigServer(configurationBuilder, environment)); Assert.Contains(nameof(configurationBuilder), ex.Message); }
public void Initialize_WithDefaultSettings() { // Arrange string prefix = "spring:cloud:config"; ConfigServerClientSettingsBase settings = new ConfigServerClientSettingsBase(); HostingEnvironment env = new HostingEnvironment(); env.EnvironmentName = null; ConfigurationRoot root = new ConfigurationRoot(new List<IConfigurationProvider>()); // Act and Assert ConfigServerConfigurationSettingsHelper.Initialize(prefix, settings, env, root); ConfigServerTestHelpers.VerifyDefaults(settings); }
public static StartupServer Create(Uri baseAddress = null) { var appEnv = CallContextServiceLocator.Locator.ServiceProvider.GetRequiredService<IApplicationEnvironment>(); var config = new ConfigurationBuilder(); var configDict = new Dictionary<string, string>(); configDict["Hosting:Environment"] = "Test"; config.AddInMemoryCollection(configDict.AsEnumerable()); var conf = config.Build(); var env = new HostingEnvironment(); env.Initialize($"{appEnv.ApplicationBasePath}/../../src/Accounting", conf); var startup = new Accounting.Startup(appEnv, env); var setup = new SetupObject(); Action<IApplicationBuilder> buildApp = (app) => { app.Use(async (context, next) => { var req = context.Request; if (req.Path == testSetupPathString && setup.Setup != null) { await setup.Setup(context); } else { await next(); } }); startup.Configure(app); }; Action<IServiceCollection> buildServices = (services) => { startup.ConfigureServices(services); services.Remove(services.Where(sp => sp.ServiceType == typeof(IConfigureOptions<AntiforgeryOptions>)).First()); services.TryAddEnumerable(ServiceDescriptor.Transient<IConfigureOptions<AntiforgeryOptions>, TestAntiforgeryOptionsSetup>()); services.AddSingleton<IAntiforgeryTokenSerializer, TestAntiforgeryTokenSerializer>(); services.AddSingleton<IAntiforgeryTokenGenerator, TestAntiforgeryTokenGenerator>(); }; StartupServer server = new StartupServer(CreateBuilder(conf, app => buildApp(app), services => buildServices(services))); server.setupObject = setup; server.BaseAddress = baseAddress; return server; }
public void AddConfigServer_AddsConfigServerProviderToProvidersList() { // Arrange var configurationBuilder = new ConfigurationBuilder(); var environment = new HostingEnvironment(); // Act and Assert configurationBuilder.AddConfigServer(environment); ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); }
public AllReadyDataAccessEF7Tests() { if (_serviceProvider == null) { var services = new ServiceCollection(); // Add EF (Full DB, not In-Memory) services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); // Setup hosting environment IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); _serviceProvider = services.BuildServiceProvider(); } }
protected TestServer CreateServer() { EnsurePath(Path.Combine(TestProjectsPath, TemplateName, "wwwroot")); // Get current IApplicationEnvironment; likely added by the host. var provider = CallContextServiceLocator.Locator.ServiceProvider; var originalEnvironment = provider.GetRequiredService<IApplicationEnvironment>(); // When an application executes in a regular context, the application base path points to the root // directory where the application is located, for example MvcSample.Web. However, when executing // an application as part of a test, the ApplicationBasePath of the IApplicationEnvironment points // to the root folder of the test project. // To compensate for this, we need to calculate the original path and override the application // environment value so that components like the view engine work properly in the context of the // test. var applicationBasePath = CalculateApplicationBasePath( originalEnvironment, TemplateName, TestProjectsPath); var environment = new TestApplicationEnvironment( originalEnvironment, applicationBasePath, TemplateName); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationBasePath, environmentName: null); try { CallContextServiceLocator.Locator.ServiceProvider = new WrappingServiceProvider(provider, environment, hostingEnvironment); var assemblyProvider = CreateAssemblyProvider(TemplateName); var builder = TestServer.CreateBuilder() .UseStartup(TemplateName) .UseServices(services => { services.AddInstance<IHostingEnvironment>(hostingEnvironment); services.AddInstance(assemblyProvider); }); return new TestServer(builder); } finally { CallContextServiceLocator.Locator.ServiceProvider = provider; } }
private static void AddTestServices( IServiceCollection services, string applicationWebSiteName, string applicationPath, Action<IServiceCollection> configureServices) { applicationPath = applicationPath ?? WebsitesDirectoryPath; // Get current IApplicationEnvironment; likely added by the host. var provider = services.BuildServiceProvider(); var originalEnvironment = provider.GetRequiredService<IApplicationEnvironment>(); // When an application executes in a regular context, the application base path points to the root // directory where the application is located, for example MvcSample.Web. However, when executing // an application as part of a test, the ApplicationBasePath of the IApplicationEnvironment points // to the root folder of the test project. // To compensate for this, we need to calculate the original path and override the application // environment value so that components like the view engine work properly in the context of the // test. var applicationBasePath = CalculateApplicationBasePath( originalEnvironment, applicationWebSiteName, applicationPath); var environment = new TestApplicationEnvironment( originalEnvironment, applicationWebSiteName, applicationBasePath); services.AddInstance<IApplicationEnvironment>(environment); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationBasePath, config: null); services.AddInstance<IHostingEnvironment>(hostingEnvironment); // Injecting a custom assembly provider. Overrides AddMvc() because that uses TryAdd(). var assemblyProvider = CreateAssemblyProvider(applicationWebSiteName); services.AddInstance(assemblyProvider); // Avoid using pooled memory, we don't have a guarantee that our services will get disposed. services.AddInstance<IHttpResponseStreamWriterFactory>(new TestHttpResponseStreamWriterFactory()); if (configureServices != null) { configureServices(services); } }
public ActivityApiControllerTest() { if (_serviceProvider == null) { var services = new ServiceCollection(); services.AddEntityFramework() .AddInMemoryDatabase() .AddDbContext<AllReadyContext>(options => options.UseInMemoryDatabase()); var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("testConfig.json"); IConfiguration configuration = builder.Build(); services.AddSingleton(x => configuration); IHostingEnvironment hostingEnvironment = new HostingEnvironment(); hostingEnvironment.EnvironmentName = "Development"; services.AddSingleton(x => hostingEnvironment); _serviceProvider = services.BuildServiceProvider(); } }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { if(Startup.Configuration == null) { var provider = CallContextServiceLocator.Locator.ServiceProvider; var appEnv = provider.GetRequiredService<IApplicationEnvironment>(); Console.WriteLine("Currently using the " + appEnv.Configuration + " configuration."); var hostEnv = new HostingEnvironment(); Console.WriteLine("Writing command line arguments"); var environment = Environment.GetEnvironmentVariable("Environment"); if (environment == null) hostEnv.EnvironmentName = "Development"; else hostEnv.EnvironmentName = environment; Console.WriteLine("The hosting environment was set to " + hostEnv.EnvironmentName); var statup = new Startup(hostEnv, appEnv); } var connectionString = Startup.Configuration[connectionStringName]; optionsBuilder.UseSqlServer(connectionString); }
public void AddConfigServer_CommandLineAppSettingsConfiguresClient() { // Arrange var appsettings = new string[] { "spring:cloud:config:enabled=false", "--spring:cloud:config:failFast=false", "/spring:cloud:config:uri=http://foo.com:9999", "--spring:cloud:config:name", "myName", "/spring:cloud:config:label", "myLabel", "--spring:cloud:config:username", "myUsername", "--spring:cloud:config:password", "myPassword" }; var configurationBuilder = new ConfigurationBuilder(); var environment = new HostingEnvironment(); configurationBuilder.AddCommandLine(appsettings); // Act and Assert configurationBuilder.AddConfigServer(environment); ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); ConfigServerClientSettings settings = configServerProvider.Settings; Assert.False(settings.Enabled); Assert.False(settings.FailFast); Assert.Equal("http://foo.com:9999", settings.Uri); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment); Assert.Equal("myName", settings.Name ); Assert.Equal("myLabel", settings.Label ); Assert.Equal("myUsername", settings.Username); Assert.Equal("myPassword", settings.Password ); }
public void AddConfigServer_WithLoggerFactorySucceeds() { // Arrange var configurationBuilder = new ConfigurationBuilder(); var loggerFactory = new LoggerFactory(); var environment = new HostingEnvironment(); // Act and Assert configurationBuilder.AddConfigServer(environment,loggerFactory); ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); Assert.NotNull(configServerProvider.Logger); }
public static Action<IServiceCollection> InitializeServices(Type startup, Action<IServiceCollection> next) { var applicationServices = CallContextServiceLocator.Locator.ServiceProvider; var libraryManager = applicationServices.GetRequiredService<ILibraryManager>(); var applicationName = startup.GetTypeInfo().Assembly.GetName().Name; var library = libraryManager.GetLibrary(applicationName); var applicationRoot = Path.GetDirectoryName(library.Path); var applicationEnvironment = applicationServices.GetRequiredService<IApplicationEnvironment>(); var configureServices = startup.GetMethod("ConfigureServices"); return (services) => { services.AddInstance<IApplicationEnvironment>(new TestApplicationEnvironment(applicationEnvironment, applicationName, applicationRoot)); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationRoot, "Production"); services.AddInstance<IHostingEnvironment>(new HostingEnvironment()); next(services); }; }
public void Services_can_be_configured() { //var appBaseDir = AppDomain.CurrentDomain.BaseDirectory; //Console.WriteLine($"AppDomain.BaseDirectory {appBaseDir}"); var dir = Directory.GetCurrentDirectory(); Console.WriteLine($"Directory.GetCurrentDirectory {dir}"); IHostingEnvironment env = new HostingEnvironment(); Startup startup = new Startup(env); var cfg = startup.Configuration; env.Initialize(dir, cfg); var cs = cfg.GetSection("ConnectionStrings:FineWork"); Assert.NotNull(cs); ServiceCollection services = new ServiceCollection(); startup.ConfigureServices(services); var sp = services.BuildServiceProvider(); var sessionProvider = sp.GetRequiredService<ISessionProvider<AefSession>>(); Assert.NotNull(sessionProvider); }
private Func<IServiceCollection, IServiceProvider> InitializeServices( Assembly startupAssembly, Func<IServiceCollection, IServiceProvider> buildServices) { var applicationServices = CallContextServiceLocator.Locator.ServiceProvider; var libraryManager = applicationServices.GetRequiredService<ILibraryManager>(); // When an application executes in a regular context, the application base path points to the root // directory where the application is located, for example .../samples/MvcSample.Web. However, when // executing an application as part of a test, the ApplicationBasePath of the IApplicationEnvironment // points to the root folder of the test project. // To compensate, we need to calculate the correct project path and override the application // environment value so that components like the view engine work properly in the context of the test. var applicationName = startupAssembly.GetName().Name; var library = libraryManager.GetLibrary(applicationName); var applicationRoot = Path.GetDirectoryName(library.Path); var applicationEnvironment = applicationServices.GetRequiredService<IApplicationEnvironment>(); return (services) => { services.AddInstance<IApplicationEnvironment>( new TestApplicationEnvironment(applicationEnvironment, applicationName, applicationRoot)); var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationRoot, null); services.AddInstance<IHostingEnvironment>(hostingEnvironment); // Inject a custom assembly provider. Overrides AddMvc() because that uses TryAdd(). var assemblyProvider = new StaticAssemblyProvider(); assemblyProvider.CandidateAssemblies.Add(startupAssembly); services.AddInstance<IAssemblyProvider>(assemblyProvider); AddAdditionalServices(services); return buildServices(services); }; }
private IHostingEnvironment TestHostingEnvironment() { var h = new HostingEnvironment() { EnvironmentName = "production", //WebRootFileProvider = new PhysicalFileProvider(_webRootPath), WebRootPath = _webRootPath }; return h; }
public void AddConfigServer_HandlesPlaceHolders() { // Arrange var appsettings = @" { 'foo': { 'bar': { 'name': 'testName' }, }, 'spring': { 'application': { 'name': 'myName' }, 'cloud': { 'config': { 'uri': 'http://*****:*****@foo.com:9999', 'enabled': false, 'failFast': false, 'name': '${foo:bar:name?foobar}', 'label': 'myLabel', 'username': '******', 'password': '******' } } } }"; var path = ConfigServerTestHelpers.CreateTempFile(appsettings); var configurationBuilder = new ConfigurationBuilder(); var environment = new HostingEnvironment(); configurationBuilder.AddJsonFile(path); // Act and Assert configurationBuilder.AddConfigServer(environment); ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); ConfigServerClientSettings settings = configServerProvider.Settings; Assert.False(settings.Enabled); Assert.False(settings.FailFast); Assert.Equal("http://*****:*****@foo.com:9999", settings.Uri); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment); Assert.Equal("testName", settings.Name); Assert.Equal("myLabel", settings.Label); Assert.Equal("myUsername", settings.Username); Assert.Equal("myPassword", settings.Password); }
public void AddConfigServer_WithCloudfoundryEnvironment_ConfiguresClientCorrectly() { // Arrange var VCAP_APPLICATION = @" { 'vcap': { 'application': { 'application_id': 'fa05c1a9-0fc1-4fbd-bae1-139850dec7a3', 'application_name': 'my-app', 'application_uris': [ 'my-app.10.244.0.34.xip.io' ], 'application_version': 'fb8fbcc6-8d58-479e-bcc7-3b4ce5a7f0ca', 'limits': { 'disk': 1024, 'fds': 16384, 'mem': 256 }, 'name': 'my-app', 'space_id': '06450c72-4669-4dc6-8096-45f9777db68a', 'space_name': 'my-space', 'uris': [ 'my-app.10.244.0.34.xip.io', 'my-app2.10.244.0.34.xip.io' ], 'users': null, 'version': 'fb8fbcc6-8d58-479e-bcc7-3b4ce5a7f0ca' } } }"; var VCAP_SERVICES = @" { 'vcap': { 'services': { 'p-config-server': [ { 'credentials': { 'access_token_uri': 'https://p-spring-cloud-services.uaa.wise.com/oauth/token', 'client_id': 'p-config-server-a74fc0a3-a7c3-43b6-81f9-9eb6586dd3ef', 'client_secret': 'e8KF1hXvAnGd', 'uri': 'https://config-ba6b6079-163b-45d2-8932-e2eca0d1e49a.wise.com' }, 'label': 'p-config-server', 'name': 'My Config Server', 'plan': 'standard', 'tags': [ 'configuration', 'spring-cloud' ] } ] } } }"; var appsettings = @" { 'spring': { 'application': { 'name': '${vcap:application:name?foobar}' } } }"; var appsettingsPath = ConfigServerTestHelpers.CreateTempFile(appsettings); var vcapAppPath = ConfigServerTestHelpers.CreateTempFile(VCAP_APPLICATION); var vcapServicesPath = ConfigServerTestHelpers.CreateTempFile(VCAP_SERVICES); var environment = new HostingEnvironment(); var configurationBuilder = new ConfigurationBuilder(); configurationBuilder.AddJsonFile(appsettingsPath); configurationBuilder.AddJsonFile(vcapAppPath); configurationBuilder.AddJsonFile(vcapServicesPath); // Act and Assert configurationBuilder.AddConfigServer(environment); IConfigurationRoot root = configurationBuilder.Build(); // Find our provider so we can check settings ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); // Check settings ConfigServerClientSettings settings = configServerProvider.Settings; Assert.True(settings.Enabled); Assert.False(settings.FailFast); Assert.Equal("https://config-ba6b6079-163b-45d2-8932-e2eca0d1e49a.wise.com", settings.Uri); Assert.Equal("https://p-spring-cloud-services.uaa.wise.com/oauth/token", settings.AccessTokenUri); Assert.Equal("p-config-server-a74fc0a3-a7c3-43b6-81f9-9eb6586dd3ef", settings.ClientId); Assert.Equal("e8KF1hXvAnGd", settings.ClientSecret); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment); Assert.Equal("my-app", settings.Name); Assert.Null(settings.Label); Assert.Null(settings.Username); Assert.Null(settings.Password); }
public void AddConfigServer_XmlAppSettingsConfiguresClient() { // Arrange var appsettings = @" <settings> <spring> <cloud> <config> <uri>http://foo.com:9999</uri> <enabled>false</enabled> <failFast>false</failFast> <label>myLabel</label> <name>myName</name> <username>myUsername</username> <password>myPassword</password> </config> </cloud> </spring> </settings>"; var path = ConfigServerTestHelpers.CreateTempFile(appsettings); var configurationBuilder = new ConfigurationBuilder(); var environment = new HostingEnvironment(); configurationBuilder.AddXmlFile(path); // Act and Assert configurationBuilder.AddConfigServer(environment); ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); ConfigServerClientSettings settings = configServerProvider.Settings; Assert.False(settings.Enabled); Assert.False(settings.FailFast); Assert.Equal("http://foo.com:9999", settings.Uri); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment); Assert.Equal("myName", settings.Name); Assert.Equal("myLabel", settings.Label); Assert.Equal("myUsername", settings.Username); Assert.Equal("myPassword", settings.Password); }
public void AddConfigServer_IniAppSettingsConfiguresClient() { // Arrange var appsettings = @" [spring:cloud:config] uri=http://foo.com:9999 enabled=false failFast=false label=myLabel name=myName username=myUsername password=myPassword "; var path = ConfigServerTestHelpers.CreateTempFile(appsettings); var configurationBuilder = new ConfigurationBuilder(); var environment = new HostingEnvironment(); configurationBuilder.AddIniFile(path); // Act and Assert configurationBuilder.AddConfigServer(environment); ConfigServerConfigurationProvider configServerProvider = null; foreach (IConfigurationProvider provider in configurationBuilder.Providers) { configServerProvider = provider as ConfigServerConfigurationProvider; if (configServerProvider != null) break; } Assert.NotNull(configServerProvider); ConfigServerClientSettings settings = configServerProvider.Settings; // Act and Assert Assert.False(settings.Enabled); Assert.False(settings.FailFast); Assert.Equal("http://foo.com:9999", settings.Uri); Assert.Equal(ConfigServerClientSettings.DEFAULT_ENVIRONMENT, settings.Environment); Assert.Equal("myName", settings.Name); Assert.Equal("myLabel", settings.Label); Assert.Equal("myUsername", settings.Username); Assert.Equal("myPassword", settings.Password); }
public Func<IServiceCollection, IServiceProvider> InitializeServices(Assembly startupAssembly, Func<IServiceCollection, IServiceProvider> buildServices) { var applicationName = startupAssembly.GetName().Name; var applicationRoot = GetApplicationRoot(applicationName); #if DNX451 AppDomain.CurrentDomain.SetData("APP_CONTEXT_BASE_DIRECTORY", applicationRoot); #endif var applicationEnvironment = PlatformServices.Default.Application; var hostingEnvironment = new HostingEnvironment(); hostingEnvironment.Initialize(applicationRoot, null); var assemblyProvider = new StaticAssemblyProvider(); assemblyProvider.CandidateAssemblies.Add(startupAssembly); return services => { services.AddInstance<IApplicationEnvironment>(new TestApplicationEnvironment(applicationEnvironment, applicationName, applicationRoot)); services.AddInstance<IHostingEnvironment>(hostingEnvironment); // Inject a custom assembly provider. Overrides AddMvc() because that uses TryAdd(). services.AddInstance<IAssemblyProvider>(assemblyProvider); return buildServices(services); }; }