public void GetPropertySourceName_ReturnsExpected()
{
var opts = new EnvEndpointOptions();
var builder = new ConfigurationBuilder();
builder.AddEnvironmentVariables();
var config = builder.Build();
var env = HostingHelpers.GetHostingEnvironment();
var ep = new EnvEndpoint(opts, config, env);
var provider = config.Providers.Single();
var name = ep.GetPropertySourceName(provider);
Assert.Equal(provider.GetType().Name, name);
builder = new ConfigurationBuilder();
builder.AddJsonFile("foobar", true);
config = builder.Build();
ep = new EnvEndpoint(opts, config, env);
provider = config.Providers.Single();
name = ep.GetPropertySourceName(provider);
Assert.Equal("JsonConfigurationProvider: [foobar]", name);
}
public void Load_ConfigServerReturnsBadStatus_FailFastEnabled_RetryEnabled()
{
// Arrange
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.ReturnStatus = new int[] { 500, 500, 500, 500, 500, 500 };
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888",
Name = "myName",
FailFast = true,
RetryEnabled = true
};
server.BaseAddress = new Uri(settings.Uri);
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
var ex = Assert.Throws <ConfigServerException>(() => provider.LoadInternal());
Assert.Equal(6, TestConfigServerStartup.RequestCount);
}
public void AddEnvActuator_AddsCorrectServices()
{
var services = new ServiceCollection();
var host = HostingHelpers.GetHostingEnvironment();
services.AddSingleton <IHostEnvironment>(host);
var appSettings = new Dictionary <string, string>()
{
["management:endpoints:enabled"] = "false",
["management:endpoints:path"] = "/cloudfoundryapplication"
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddInMemoryCollection(appSettings);
var config = configurationBuilder.Build();
services.AddSingleton <IConfiguration>(config);
services.AddEnvActuator(config);
var serviceProvider = services.BuildServiceProvider();
var options = serviceProvider.GetService <IEnvOptions>();
Assert.NotNull(options);
var ep = serviceProvider.GetService <EnvEndpoint>();
Assert.NotNull(ep);
}
public async System.Threading.Tasks.Task RegisterAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 204;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var config = new EurekaInstanceConfig();
var info = InstanceInfo.FromInstanceConfig(config);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.RegisterAsync(info);
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.NoContent, resp.StatusCode);
Assert.NotNull(resp.Headers);
}
public void GetPropertySources_ReturnsExpected_WithPlaceholders()
{
var appsettings = new Dictionary<string, string>()
{
["management:endpoints:path"] = "/cloudfoundryapplication",
["appsManagerBase"] = "${management:endpoints:path}"
};
using (var tc = new TestContext(_output))
{
tc.AdditionalServices = (services, configuration) =>
{
services.AddSingleton(HostingHelpers.GetHostingEnvironment());
services.AddEnvActuatorServices(configuration);
};
tc.AdditionalConfiguration = configuration =>
{
configuration.AddInMemoryCollection(appsettings);
configuration.AddPlaceholderResolver();
};
var endpoint = tc.GetService<IEnvEndpoint>();
var result = endpoint.GetPropertySources(tc.Configuration);
var testProp = tc.Configuration["appsManagerBase"];
Assert.NotNull(result);
Assert.Equal(2, result.Count);
Assert.NotNull(testProp);
Assert.Equal("/cloudfoundryapplication", testProp);
}
}
public void FetchRegistryDeltaAsync_ReturnsNull_IfFetchCounterMismatch()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var config = new EurekaClientConfig()
{
ShouldFetchRegistry = false,
ShouldRegisterWithEureka = false,
EurekaServerServiceUrls = uri.ToString()
};
var httpClient = new EurekaHttpClient(config, server.CreateClient());
var client = new DiscoveryClient(config, httpClient);
var result = client.FetchRegistryDeltaAsync();
client.RegistryFetchCounter = 100;
var apps = result.GetAwaiter().GetResult();
Assert.Null(apps);
}
public async System.Threading.Tasks.Task DeleteStatusOverrideAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var now = DateTime.UtcNow.Ticks;
var javaTime = DateTimeConversions.ToJavaMillis(new DateTime(now, DateTimeKind.Utc));
var resp = await client.DeleteStatusOverrideAsync("foo", "bar", new InstanceInfo()
{
LastDirtyTimestamp = now
});
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("DELETE", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo/bar/status", TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal("?lastDirtyTimestamp=" + javaTime, TestConfigServerStartup.LastRequest.QueryString.Value);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
public void Sanitized_NonDefault_WhenSet()
{
var appsettings = new Dictionary <string, string>()
{
["management:endpoints:env:keystosanitize:0"] = "credentials",
["password"] = "******"
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddInMemoryCollection(appsettings);
var config = configurationBuilder.Build();
var opts = new EnvEndpointOptions(config);
var env = HostingHelpers.GetHostingEnvironment();
var ep = new EnvEndpoint(opts, config, env);
var result = ep.DoInvoke(config);
Assert.NotNull(result);
var desc = result.PropertySources[0];
Assert.Equal("MemoryConfigurationProvider", desc.Name);
var props = desc.Properties;
Assert.NotNull(props);
Assert.Contains("password", props.Keys);
Assert.NotNull(props["password"]);
Assert.Equal("mysecret", props["password"].Value);
}
public void Load_MultipleConfigServers_ReturnsGreaterThanEqualBadRequest_StopsChecking()
{
// Arrange
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.ReturnStatus = new int[] { 500, 200 };
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888, http://localhost:8888",
Name = "myName"
};
server.BaseAddress = new Uri("http://localhost:8888");
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
provider.LoadInternal();
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("/" + settings.Name + "/" + settings.Environment, TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal(1, TestConfigServerStartup.RequestCount);
}
public async void RemoteLoadAsync_ConfigServerReturnsLessThanBadRequest()
{
// Arrange
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.ReturnStatus = new int[] { 204 };
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888",
Name = "myName"
};
server.BaseAddress = new Uri(settings.Uri);
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
ConfigEnvironment result = await provider.RemoteLoadAsync(settings.GetRawUris(), null);
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("/" + settings.Name + "/" + settings.Environment, TestConfigServerStartup.LastRequest.Path.Value);
Assert.Null(result);
}
public void AddConfigServer_Validate_Certificates_DisablesCertValidation()
{
// Arrange
var appsettings = @"
{
""spring"": {
""cloud"": {
""config"": {
""validate_certificates"": false
}
}
}
}";
var path = TestHelpers.CreateTempFile(appsettings);
string directory = Path.GetDirectoryName(path);
string fileName = Path.GetFileName(path);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
var environment = HostingHelpers.GetHostingEnvironment("Production");
configurationBuilder.AddJsonFile(fileName);
// Act and Assert
configurationBuilder.AddConfigServer(environment);
var config = configurationBuilder.Build();
ConfigServerConfigurationProvider configServerProvider = config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();
Assert.NotNull(configServerProvider);
ConfigServerClientSettings settings = configServerProvider.Settings;
Assert.False(settings.ValidateCertificates);
}
public void AddDistributedTracing_AddsCorrectServices()
{
var services = new ServiceCollection();
var config = GetConfiguration();
services.AddOptions();
services.AddSingleton(HostingHelpers.GetHostingEnvironment());
services.AddDistributedTracing(config);
var serviceProvider = services.BuildServiceProvider();
var mgr = serviceProvider.GetService <IDiagnosticsManager>();
Assert.NotNull(mgr);
var hst = serviceProvider.GetService <IHostedService>();
Assert.NotNull(hst);
var opts = serviceProvider.GetService <ITracingOptions>();
Assert.NotNull(opts);
var observers = serviceProvider.GetServices <IDiagnosticObserver>();
var list = observers.ToList();
Assert.Equal(5, list.Count);
var tracing = serviceProvider.GetService <ITracing>();
Assert.NotNull(tracing);
var processer = serviceProvider.GetService <IDynamicMessageProcessor>();
Assert.NotNull(processer);
}
public void Load_MultipleConfigServers_ReturnsNotFoundStatus__DoesNotContinueChecking_FailFastEnabled()
{
// Arrange
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.ReturnStatus = new int[] { 404, 200 };
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888, http://localhost:8888 ",
Name = "myName",
FailFast = true
};
server.BaseAddress = new Uri("http://localhost:8888");
var provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
var ex = Assert.Throws <ConfigServerException>(() => provider.LoadInternal());
Assert.Equal(1, TestConfigServerStartup.RequestCount);
}
public async Task HandleMappingsRequestAsync_MVCNotUsed_NoRoutes_ReturnsExpected()
{
var opts = new MappingsEndpointOptions();
var mopts = new CloudFoundryManagementOptions();
mopts.EndpointOptions.Add(opts);
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddInMemoryCollection(AppSettings);
var config = configurationBuilder.Build();
var host = HostingHelpers.GetHostingEnvironment();
var ep = new MappingsEndpoint(opts);
var middle = new MappingsEndpointMiddleware(null, opts, mopts, ep);
var context = CreateRequest("GET", "/cloudfoundryapplication/mappings");
await middle.HandleMappingsRequestAsync(context);
context.Response.Body.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(context.Response.Body, Encoding.UTF8);
var json = await reader.ReadLineAsync();
var expected = "{\"contexts\":{\"application\":{\"mappings\":{\"dispatcherServlets\":{\"dispatcherServlet\":[]}}}}}";
Assert.Equal(expected, json);
}
public void Sanitized_NonDefault_WhenSet()
{
var appsettings = new Dictionary<string, string>()
{
["management:endpoints:env:keystosanitize:0"] = "credentials",
["password"] = "******"
};
using (var tc = new TestContext(_output))
{
tc.AdditionalServices = (services, configuration) =>
{
services.AddSingleton(HostingHelpers.GetHostingEnvironment());
services.AddEnvActuatorServices(configuration);
};
tc.AdditionalConfiguration = configuration =>
{
configuration.AddInMemoryCollection(appsettings);
};
var ep = tc.GetService<IEnvEndpoint>();
var result = ep.Invoke();
Assert.NotNull(result);
var desc = result.PropertySources[0];
Assert.Equal("MemoryConfigurationProvider", desc.Name);
var props = desc.Properties;
Assert.NotNull(props);
Assert.Contains("password", props.Keys);
Assert.NotNull(props["password"]);
Assert.Equal("mysecret", props["password"].Value);
}
}
public async System.Threading.Tasks.Task CancelAsync_InvokesServer_ReturnsStatusCodeAndHeaders()
{
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Response = string.Empty;
TestConfigServerStartup.ReturnStatus = 200;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
var uri = "http://localhost:8888/";
server.BaseAddress = new Uri(uri);
var cconfig = new EurekaClientConfig()
{
EurekaServerServiceUrls = uri
};
var client = new EurekaHttpClient(cconfig, server.CreateClient());
var resp = await client.CancelAsync("foo", "bar");
Assert.NotNull(resp);
Assert.Equal(HttpStatusCode.OK, resp.StatusCode);
Assert.NotNull(resp.Headers);
Assert.Equal("DELETE", TestConfigServerStartup.LastRequest.Method);
Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value);
Assert.Equal("/apps/foo/bar", TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal("http://localhost:8888/", client._serviceUrl);
}
public void Load_ConfigServerReturnsNotFoundStatus()
{
// Arrange
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.ReturnStatus = new int[] { 404 };
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888",
Name = "myName"
};
server.BaseAddress = new Uri(settings.Uri);
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
provider.LoadInternal();
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("/" + settings.Name + "/" + settings.Environment, TestConfigServerStartup.LastRequest.Path.Value);
Assert.Equal(26, provider.Properties.Count);
}
public void GetPropertySourceDescriptor_ReturnsExpected()
{
var appsettings = new Dictionary<string, string>()
{
["management:endpoints:enabled"] = "false",
["management:endpoints:path"] = "/cloudfoundryapplication",
["management:endpoints:loggers:enabled"] = "false",
["management:endpoints:heapdump:enabled"] = "true",
["management:endpoints:heapdump:sensitive"] = "true",
["management:endpoints:cloudfoundry:validatecertificates"] = "true",
["management:endpoints:cloudfoundry:enabled"] = "true",
["common"] = "appsettings",
["CharSize"] = "should not duplicate"
};
var otherAppsettings = new Dictionary<string, string>()
{
["common"] = "otherAppsettings",
["charSize"] = "should not duplicate"
};
using (var tc = new TestContext(_output))
{
tc.AdditionalServices = (services, configuration) =>
{
services.AddSingleton(HostingHelpers.GetHostingEnvironment());
services.AddEnvActuatorServices(configuration);
};
tc.AdditionalConfiguration = configuration =>
{
configuration.AddInMemoryCollection(appsettings);
configuration.AddInMemoryCollection(otherAppsettings);
};
var ep = tc.GetService<IEnvEndpoint>();
var appsettingsProvider = tc.Configuration.Providers.ElementAt(0);
var appsettingsDesc = ep.GetPropertySourceDescriptor(appsettingsProvider);
var otherAppsettingsProvider = tc.Configuration.Providers.ElementAt(1);
var otherAppsettingsDesc = ep.GetPropertySourceDescriptor(otherAppsettingsProvider);
Assert.Equal("MemoryConfigurationProvider", appsettingsDesc.Name);
var props = appsettingsDesc.Properties;
Assert.NotNull(props);
Assert.Equal(9, props.Count);
Assert.Contains("management:endpoints:enabled", props.Keys);
var prop = props["management:endpoints:enabled"];
Assert.NotNull(prop);
Assert.Equal("false", prop.Value);
Assert.Null(prop.Origin);
var otherProps = otherAppsettingsDesc.Properties;
var appsettingsCommonProp = props["common"];
var otherAppsettingCommonProp = otherProps["common"];
Assert.Equal("appsettings", appsettingsCommonProp.Value);
Assert.Equal("otherAppsettings", otherAppsettingCommonProp.Value);
}
}
public void AddConfigServer_HandlesPlaceHolders()
{
// Arrange
var appsettings = @"
{
""foo"": {
""bar"": {
""name"": ""testName""
},
},
""spring"": {
""application"": {
""name"": ""myName""
},
""cloud"": {
""config"": {
""uri"": ""https://*****:*****@foo.com:9999"",
""enabled"": false,
""failFast"": false,
""name"": ""${foo:bar:name?foobar}"",
""label"": ""myLabel"",
""username"": ""myUsername"",
""password"": ""myPassword""
}
}
}
}";
var path = TestHelpers.CreateTempFile(appsettings);
string directory = Path.GetDirectoryName(path);
string fileName = Path.GetFileName(path);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
var environment = HostingHelpers.GetHostingEnvironment("Production");
configurationBuilder.AddJsonFile(fileName);
// Act and Assert
configurationBuilder.AddConfigServer(environment);
IConfigurationRoot config = configurationBuilder.Build();
ConfigServerConfigurationProvider configServerProvider = config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();
Assert.NotNull(configServerProvider);
ConfigServerClientSettings settings = configServerProvider.Settings;
Assert.False(settings.Enabled);
Assert.False(settings.FailFast);
Assert.Equal("https://*****:*****@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 GetPropertySourceDescriptor_ReturnsExpected()
{
var opts = new EnvEndpointOptions();
var appsettings = new Dictionary <string, string>()
{
["management:endpoints:enabled"] = "false",
["management:endpoints:path"] = "/cloudfoundryapplication",
["management:endpoints:loggers:enabled"] = "false",
["management:endpoints:heapdump:enabled"] = "true",
["management:endpoints:heapdump:sensitive"] = "true",
["management:endpoints:cloudfoundry:validatecertificates"] = "true",
["management:endpoints:cloudfoundry:enabled"] = "true",
["common"] = "appsettings",
["CharSize"] = "should not duplicate"
};
var otherAppsettings = new Dictionary <string, string>()
{
["common"] = "otherAppsettings",
["charSize"] = "should not duplicate"
};
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddInMemoryCollection(appsettings);
configurationBuilder.AddInMemoryCollection(otherAppsettings);
var config = configurationBuilder.Build();
var env = HostingHelpers.GetHostingEnvironment();
var ep = new EnvEndpoint(opts, config, env);
var appsettingsProvider = config.Providers.ElementAt(0);
var appsettingsDesc = ep.GetPropertySourceDescriptor(appsettingsProvider);
var otherAppsettingsProvider = config.Providers.ElementAt(1);
var otherAppsettingsDesc = ep.GetPropertySourceDescriptor(otherAppsettingsProvider);
Assert.Equal("MemoryConfigurationProvider", appsettingsDesc.Name);
var props = appsettingsDesc.Properties;
Assert.NotNull(props);
Assert.Equal(9, props.Count);
Assert.Contains("management:endpoints:enabled", props.Keys);
var prop = props["management:endpoints:enabled"];
Assert.NotNull(prop);
Assert.Equal("false", prop.Value);
Assert.Null(prop.Origin);
var otherProps = otherAppsettingsDesc.Properties;
var appsettingsCommonProp = props["common"];
var otherAppsettingCommonProp = otherProps["common"];
Assert.Equal("appsettings", appsettingsCommonProp.Value);
Assert.Equal("otherAppsettings", otherAppsettingCommonProp.Value);
}
public void AddConfigServer_ThrowsIfConfigBuilderNull()
{
// Arrange
IConfigurationBuilder configurationBuilder = null;
var environment = HostingHelpers.GetHostingEnvironment();
// Act and Assert
var ex = Assert.Throws <ArgumentNullException>(() => configurationBuilder.AddConfigServer(environment));
Assert.Contains(nameof(configurationBuilder), ex.Message);
}
public async void RemoteLoadAsync_ConfigServerReturnsGood()
{
// Arrange
var environment = @"
{
""name"": ""testname"",
""profiles"": [""Production""],
""label"": ""testlabel"",
""version"": ""testversion"",
""propertySources"": [
{
""name"": ""source"",
""source"": {
""key1"": ""value1"",
""key2"": 10
}
}
]
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.Response = environment;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888",
Name = "myName"
};
server.BaseAddress = new Uri(settings.Uri);
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
ConfigEnvironment env = await provider.RemoteLoadAsync(settings.GetUris(), null);
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("/" + settings.Name + "/" + settings.Environment, TestConfigServerStartup.LastRequest.Path.Value);
Assert.NotNull(env);
Assert.Equal("testname", env.Name);
Assert.NotNull(env.Profiles);
Assert.Single(env.Profiles);
Assert.Equal("testlabel", env.Label);
Assert.Equal("testversion", env.Version);
Assert.NotNull(env.PropertySources);
Assert.Single(env.PropertySources);
Assert.Equal("source", env.PropertySources[0].Name);
Assert.NotNull(env.PropertySources[0].Source);
Assert.Equal(2, env.PropertySources[0].Source.Count);
Assert.Equal("value1", env.PropertySources[0].Source["key1"]);
Assert.Equal(10L, env.PropertySources[0].Source["key2"]);
}
public void AddConfigServer_AddsConfigServerProviderToProvidersList()
{
// Arrange
var configurationBuilder = new ConfigurationBuilder();
var environment = HostingHelpers.GetHostingEnvironment();
// Act and Assert
configurationBuilder.AddConfigServer(environment);
var config = configurationBuilder.Build();
ConfigServerConfigurationProvider configServerProvider = config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();
Assert.NotNull(configServerProvider);
}
public void AddConfigServer_XmlAppSettingsConfiguresClient()
{
// Arrange
var appsettings = @"
<settings>
<spring>
<cloud>
<config>
<uri>https://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 = TestHelpers.CreateTempFile(appsettings);
string directory = Path.GetDirectoryName(path);
string fileName = Path.GetFileName(path);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
var environment = HostingHelpers.GetHostingEnvironment("Production");
configurationBuilder.AddXmlFile(fileName);
// Act and Assert
configurationBuilder.AddConfigServer(environment);
IConfigurationRoot config = configurationBuilder.Build();
ConfigServerConfigurationProvider configServerProvider = config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();
Assert.NotNull(configServerProvider);
ConfigServerClientSettings settings = configServerProvider.Settings;
Assert.False(settings.Enabled);
Assert.False(settings.FailFast);
Assert.Equal("https://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);
Assert.Null(settings.AccessTokenUri);
Assert.Null(settings.ClientId);
Assert.Null(settings.ClientSecret);
}
public void AddConfigServer_WithLoggerFactorySucceeds()
{
// Arrange
var configurationBuilder = new ConfigurationBuilder();
var loggerFactory = new LoggerFactory();
var environment = HostingHelpers.GetHostingEnvironment("Production");
// Act and Assert
configurationBuilder.AddConfigServer(environment, loggerFactory);
var config = configurationBuilder.Build();
ConfigServerConfigurationProvider configServerProvider = config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();
Assert.NotNull(configServerProvider);
Assert.NotNull(configServerProvider.Logger);
}
public void SpringCloudConfigServer_DiscoveryFirst_ReturnsExpectedDefaultData()
{
var appsettings = @"
{
""spring"": {
""application"": {
""name"" : ""foo""
},
""cloud"": {
""config"": {
""uri"": ""http://localhost:8888"",
""env"": ""development"",
""failfast"": ""true"",
""discovery"": {
""enabled"": true
}
}
}
},
""eureka"": {
""client"": {
""serviceUrl"": ""http://localhost:8761/eureka/""
}
}
}";
using var sandbox = new Sandbox();
var path = sandbox.CreateFile("appsettings.json", appsettings);
var directory = Path.GetDirectoryName(path);
var fileName = Path.GetFileName(path);
var configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
var hostingEnv = HostingHelpers.GetHostingEnvironment("development");
configurationBuilder.AddJsonFile(fileName);
// Act and Assert (expects Spring Cloud Config server to be running)
configurationBuilder.AddConfigServer(hostingEnv);
var root = configurationBuilder.Build();
Assert.Equal("spam", root["bar"]);
Assert.Equal("from foo development", 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 void AddZipkinExporter_AddsCorrectServices()
{
var services = new ServiceCollection();
var config = GetConfiguration();
services.AddOptions();
services.AddSingleton(HostingHelpers.GetHostingEnvironment());
services.AddSingleton <ITracing>(new TestTracing());
services.AddZipkinExporter(config);
var serviceProvider = services.BuildServiceProvider();
var tracing = serviceProvider.GetService <ZipkinTraceExporter>();
Assert.NotNull(tracing);
}
public void DoLoad_MultipleLabels_ChecksAllLabels()
{
// Arrange
var environment = @"
{
""name"": ""testname"",
""profiles"": [""Production""],
""label"": ""testlabel"",
""version"": ""testversion"",
""propertySources"": [
{
""name"": ""source"",
""source"": {
""key1"": ""value1"",
""key2"": 10
}
}
]
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.Response = environment;
TestConfigServerStartup.ReturnStatus = new int[] { 404, 200 };
TestConfigServerStartup.Label = "testlabel";
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888",
Name = "myName",
Label = "label,testlabel"
};
server.BaseAddress = new Uri(settings.Uri);
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
provider.DoLoad();
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal(2, TestConfigServerStartup.RequestCount);
Assert.Equal("/" + settings.Name + "/" + settings.Environment + "/testlabel", TestConfigServerStartup.LastRequest.Path.Value);
}
public void Load_ChangesDataDictionary()
{
// Arrange
var environment = @"
{
""name"": ""testname"",
""profiles"": [""Production""],
""label"": ""testlabel"",
""version"": ""testversion"",
""propertySources"": [
{
""name"": ""source"",
""source"": {
""key1"": ""value1"",
""key2"": 10
}
}
]
}";
var envir = HostingHelpers.GetHostingEnvironment();
TestConfigServerStartup.Reset();
TestConfigServerStartup.Response = environment;
var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName);
var server = new TestServer(builder);
ConfigServerClientSettings settings = new ConfigServerClientSettings
{
Uri = "http://localhost:8888",
Name = "myName"
};
server.BaseAddress = new Uri(settings.Uri);
ConfigServerConfigurationProvider provider = new ConfigServerConfigurationProvider(settings, server.CreateClient());
// Act and Assert
provider.LoadInternal();
Assert.NotNull(TestConfigServerStartup.LastRequest);
Assert.Equal("/" + settings.Name + "/" + settings.Environment, TestConfigServerStartup.LastRequest.Path.Value);
Assert.True(provider.TryGet("key1", out string value));
Assert.Equal("value1", value);
Assert.True(provider.TryGet("key2", out value));
Assert.Equal("10", value);
}
public void AddConfigServer_IniAppSettingsConfiguresClient()
{
// Arrange
var appsettings = @"
[spring:cloud:config]
uri=https://foo.com:9999
enabled=false
failFast=false
label=myLabel
name=myName
username=myUsername
password=myPassword
";
var path = TestHelpers.CreateTempFile(appsettings);
string directory = Path.GetDirectoryName(path);
string fileName = Path.GetFileName(path);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
var environment = HostingHelpers.GetHostingEnvironment("Production");
configurationBuilder.AddIniFile(fileName);
// Act and Assert
configurationBuilder.AddConfigServer(environment);
IConfigurationRoot config = configurationBuilder.Build();
ConfigServerConfigurationProvider configServerProvider = config.Providers.OfType <ConfigServerConfigurationProvider>().SingleOrDefault();
Assert.NotNull(configServerProvider);
ConfigServerClientSettings settings = configServerProvider.Settings;
// Act and Assert
Assert.False(settings.Enabled);
Assert.False(settings.FailFast);
Assert.Equal("https://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);
Assert.Null(settings.AccessTokenUri);
Assert.Null(settings.ClientId);
Assert.Null(settings.ClientSecret);
}
