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);
};
}
