public void AddRedisConnectionMultiplexer_WithEnterpriseVCAPs_AddsRedisConnectionMultiplexer()
{
// Arrange
Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION);
Environment.SetEnvironmentVariable("VCAP_SERVICES", RedisCacheTestHelpers.SingleServerEnterpriseVCAP);
var appsettings = new Dictionary <string, string>()
{
["redis:client:AbortOnConnectFail"] = "false",
["redis:client:connectTimeout"] = "1"
};
IServiceCollection services = new ServiceCollection();
var builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
builder.AddInMemoryCollection(appsettings);
var config = builder.Build();
// Act
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var service = services.BuildServiceProvider().GetService <IConnectionMultiplexer>();
// Assert
Assert.NotNull(service);
Assert.IsType <ConnectionMultiplexer>(service);
Assert.Contains("redis-1076.redis-enterprise.system.cloudyazure.io", service.Configuration);
Assert.Contains(":1076", service.Configuration);
Assert.Contains("password=rQrMqqg-.LJzO498EcAIfp-auu4czBiGM40wjveTdHw-EJu0", service.Configuration);
}
public void AddRedisConnectionMultiplexer_NoVCAPs_AddsConnectionMultiplexer()
{
// Arrange
var appsettings = @"
{
'redis': {
'client': {
'host': '127.0.0.1',
'port': 1234,
'password': '******',
'abortOnConnectFail': false
}
}
}";
var path = TestHelpers.CreateTempFile(appsettings);
string directory = Path.GetDirectoryName(path);
string fileName = Path.GetFileName(path);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.SetBasePath(directory);
configurationBuilder.AddJsonFile(fileName);
var config = configurationBuilder.Build();
IServiceCollection services = new ServiceCollection();
// Act and Assert
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var service = services.BuildServiceProvider().GetService <ConnectionMultiplexer>();
Assert.NotNull(service);
}
public void AddRedisConnectionMultiplexer_NoVCAPs_AddsConnectionMultiplexer()
{
// Arrange
var appsettings = new Dictionary <string, string>()
{
["redis:client:host"] = "127.0.0.1",
["redis:client:port"] = "1234",
["redis:client:password"] = "******",
["redis:client:abortOnConnectFail"] = "false",
["redis:client:connectTimeout"] = "1"
};
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationBuilder.AddInMemoryCollection(appsettings);
var config = configurationBuilder.Build();
IServiceCollection services = new ServiceCollection();
IServiceCollection services2 = new ServiceCollection();
// Act
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var service = services.BuildServiceProvider().GetService <IConnectionMultiplexer>();
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services2, config, config, null);
var service2 = services2.BuildServiceProvider().GetService <IConnectionMultiplexer>();
// Assert
Assert.NotNull(service);
Assert.IsType <ConnectionMultiplexer>(service);
Assert.Contains("password=pass,word", (service as ConnectionMultiplexer).Configuration);
Assert.NotNull(service2);
Assert.IsType <ConnectionMultiplexer>(service2);
Assert.Contains("password=pass,word", (service as ConnectionMultiplexer).Configuration);
}
public void AddRedisConnectionMultiplexer_WithVCAPs_AddsRedisConnectionMultiplexer()
{
// Arrange
Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION);
Environment.SetEnvironmentVariable("VCAP_SERVICES", RedisCacheTestHelpers.SingleServerVCAP);
var appsettings = new Dictionary <string, string>()
{
["redis:client:AbortOnConnectFail"] = "false",
["redis:client:connectTimeout"] = "1"
};
IServiceCollection services = new ServiceCollection();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
builder.AddInMemoryCollection(appsettings);
var config = builder.Build();
// Act
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var service = services.BuildServiceProvider().GetService <IConnectionMultiplexer>();
// Assert
Assert.NotNull(service);
Assert.IsType <ConnectionMultiplexer>(service);
Assert.Contains("192.168.0.103", service.Configuration);
Assert.Contains(":60287", service.Configuration);
Assert.Contains("password=133de7c8-9f3a-4df1-8a10-676ba7ddaa10", service.Configuration);
}
public void AddRedisConnectionMultiplexer_WithAzureVCAPs_AddsRedisConnectionMultiplexer()
{
// Arrange
Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION);
Environment.SetEnvironmentVariable("VCAP_SERVICES", RedisCacheTestHelpers.SingleServerVCAP_AzureBroker);
var appsettings = new Dictionary <string, string>()
{
["redis:client:AbortOnConnectFail"] = "false",
["redis:client:urlEncodedCredentials"] = "true"
};
IServiceCollection services = new ServiceCollection();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
builder.AddInMemoryCollection(appsettings);
var config = builder.Build();
// Act
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var service = services.BuildServiceProvider().GetService <IConnectionMultiplexer>();
// Assert
Assert.NotNull(service);
Assert.IsType <ConnectionMultiplexer>(service);
Assert.Contains("cbe9d9a0-6502-438d-87ec-f26f1974e378.redis.cache.windows.net", service.Configuration);
Assert.Contains(":6379", service.Configuration);
Assert.Contains("password=V+4dv03jSUZkEcjGhVMR0hjEPfILCCcth1JE8vPRki4=", service.Configuration);
}
public void AddRedisConnectionMultiplexer_WithSecureAzureVCAPs_AddsRedisConnectionMultiplexer()
{
// Arrange
Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION);
Environment.SetEnvironmentVariable("VCAP_SERVICES", RedisCacheTestHelpers.SingleServerVCAP_AzureBrokerSecure);
var appsettings = new Dictionary <string, string>()
{
["redis:client:AbortOnConnectFail"] = "false",
["redis:client:urlEncodedCredentials"] = "true"
};
IServiceCollection services = new ServiceCollection();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
builder.AddInMemoryCollection(appsettings);
var config = builder.Build();
// Act
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var service = services.BuildServiceProvider().GetService <IConnectionMultiplexer>();
// Assert
Assert.NotNull(service);
Assert.IsType <ConnectionMultiplexer>(service);
Assert.Contains("9b67c347-03b8-4956-aa2a-858ac30aced5.redis.cache.windows.net", service.Configuration);
Assert.Contains(":6380", service.Configuration);
Assert.Contains("password=mAG0+CdozukoUTOIEAo6wTKHdMoqg4+Jfno8docw3Zg=", service.Configuration);
Assert.Contains("ssl=True", service.Configuration);
}
public void AddRedisConnectionMultiplexer_ThrowsIfServiceNameNull()
{
IServiceCollection services = new ServiceCollection();
IConfigurationRoot config = null;
string serviceName = null;
var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config, serviceName));
Assert.Contains(nameof(serviceName), ex.Message);
}
public void AddDistributedRedisCache_ThrowsIfServiceNameNull()
{
IServiceCollection services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
string serviceName = null;
var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, serviceName));
Assert.Contains(nameof(serviceName), ex.Message);
}
public void AddDistributedRedisCache_NoVCAPs_AddsDistributedCache()
{
IServiceCollection services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config);
var service = services.BuildServiceProvider().GetService <IDistributedCache>();
Assert.NotNull(service);
Assert.IsType <RedisCache>(service);
}
public void AddDistributedRedisCache_WithServiceName_NoVCAPs_ThrowsConnectorException()
{
// Arrange
IServiceCollection services = new ServiceCollection();
IConfigurationRoot config = new ConfigurationBuilder().Build();
// Act and Assert
var ex = Assert.Throws <ConnectorException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, "foobar"));
Assert.Contains("foobar", ex.Message);
}
public void AddDistributedRedisCache_ThrowsIfServiceNameNull()
{
// Arrange
IServiceCollection services = new ServiceCollection();
IConfigurationRoot config = null;
string serviceName = null;
// Act and Assert
var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, serviceName));
Assert.Contains(nameof(serviceName), ex.Message);
}
public void AddDistributedRedisCache_NoVCAPs_AddsDistributedCache()
{
// Arrange
IServiceCollection services = new ServiceCollection();
IConfigurationRoot config = new ConfigurationBuilder().Build();
// Act and Assert
RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config);
var service = services.BuildServiceProvider().GetService <IDistributedCache>();
Assert.NotNull(service);
}
public void AddDistributedRedisCache_AddsRedisHealthContributor()
{
IServiceCollection services = new ServiceCollection();
var builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config);
var healthContributor = services.BuildServiceProvider().GetService <IHealthContributor>() as RedisHealthContributor;
Assert.NotNull(healthContributor);
}
public void AddRedisConnectionMultiplexer_WithServiceName_NoVCAPs_ThrowsConnectorException()
{
IServiceCollection services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
var ex = Assert.Throws <ConnectorException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config, "foobar"));
Assert.Contains("foobar", ex.Message);
var ex2 = Assert.Throws <ConnectorException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config, config, "foobar"));
Assert.Contains("foobar", ex2.Message);
}
public void AddRedisConnectionMultiplexer_ThrowsIfConfigurtionNull()
{
// Arrange
IServiceCollection services = new ServiceCollection();
IConfigurationRoot config = null;
// Act and Assert
var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config));
Assert.Contains(nameof(config), ex.Message);
var ex2 = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config, "foobar"));
Assert.Contains(nameof(config), ex2.Message);
}
public void AddRedisConnectionMultiplexer_AddsRedisHealthContributor()
{
// Arrange
IServiceCollection services = new ServiceCollection();
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
// Act
RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config);
var healthContributor = services.BuildServiceProvider().GetService<IHealthContributor>() as RedisHealthContributor;
// Assert
Assert.NotNull(healthContributor);
}
public void AddDistributedRedisCache_ThrowsIfServiceCollectionNull()
{
// Arrange
IServiceCollection services = null;
IConfigurationRoot config = new ConfigurationBuilder().Build();
// Act and Assert
var ex = Assert.Throws<ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config));
Assert.Contains(nameof(services), ex.Message);
var ex2 = Assert.Throws<ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, "foobar"));
Assert.Contains(nameof(services), ex2.Message);
var ex3 = Assert.Throws<ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, config, "foobar"));
Assert.Contains(nameof(services), ex3.Message);
}
public void AddRedisConnectionMultiplexer_ThrowsIfServiceCollectionNull()
{
IServiceCollection services = null;
var config = new ConfigurationBuilder().Build();
var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config));
Assert.Contains(nameof(services), ex.Message);
var ex2 = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config, "foobar"));
Assert.Contains(nameof(services), ex2.Message);
var ex3 = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddRedisConnectionMultiplexer(services, config, config, "foobar"));
Assert.Contains(nameof(services), ex3.Message);
}
public void AddDistributedRedisCache_AddsRedisHealthContributor_WhenCommunityHealthCheckExistsAndForced()
{
IServiceCollection services = new ServiceCollection();
var builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
var cm = new ConnectionStringManager(config);
var ci = cm.Get <RedisConnectionInfo>();
services.AddHealthChecks().AddRedis(ci.ConnectionString, name: ci.Name);
RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, addSteeltoeHealthChecks: true);
var healthContributor = services.BuildServiceProvider().GetService <IHealthContributor>() as RedisHealthContributor;
Assert.NotNull(healthContributor);
}
public void AddDistributedRedisCache_ThrowsIfConfigurationNull()
{
IServiceCollection services = new ServiceCollection();
IConfigurationRoot config = null;
var connectionConfig = new ConfigurationBuilder().Build();
var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config));
Assert.Contains(nameof(config), ex.Message);
var ex2 = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, "foobar"));
Assert.Contains(nameof(config), ex2.Message);
var ex3 = Assert.Throws <ArgumentNullException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, connectionConfig, "foobar"));
Assert.Contains("applicationConfiguration", ex3.Message);
}
public void AddDistributedRedisCache_MultipleRedisServices_ThrowsConnectorException()
{
// Arrange
IServiceCollection services = new ServiceCollection();
Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION);
Environment.SetEnvironmentVariable("VCAP_SERVICES", RedisCacheTestHelpers.TwoServerVCAP);
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
// Act and Assert
var ex = Assert.Throws<ConnectorException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config));
Assert.Contains("Multiple", ex.Message);
var ex2 = Assert.Throws<ConnectorException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config, config, null));
Assert.Contains("Multiple", ex2.Message);
}
public void AddDistributedRedisCache_DoesntAddRedisHealthContributor_WhenCommunityHealthCheckExists()
{
// Arrange
IServiceCollection services = new ServiceCollection();
var builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
var cm = new ConnectionStringManager(config);
var ci = cm.Get <RedisConnectionInfo>();
services.AddHealthChecks().AddRedis(ci.ConnectionString, name: ci.Name);
// Act
RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config);
var healthContributor = services.BuildServiceProvider().GetService <IHealthContributor>() as RedisHealthContributor;
// Assert
Assert.Null(healthContributor);
}
public void AddDistributedRedisCache_MultipleRedisServices_ThrowsConnectorException()
{
// Arrange
var env1 = @"
{
'limits': {
'fds': 16384,
'mem': 1024,
'disk': 1024
},
'application_name': 'spring-cloud-broker',
'application_uris': [
'spring-cloud-broker.apps.testcloud.com'
],
'name': 'spring-cloud-broker',
'space_name': 'p-spring-cloud-services',
'space_id': '65b73473-94cc-4640-b462-7ad52838b4ae',
'uris': [
'spring-cloud-broker.apps.testcloud.com'
],
'users': null,
'version': '07e112f7-2f71-4f5a-8a34-db51dbed30a3',
'application_version': '07e112f7-2f71-4f5a-8a34-db51dbed30a3',
'application_id': '798c2495-fe75-49b1-88da-b81197f2bf06'
}
}";
var env2 = @"
{
'p-redis': [
{
'credentials': {
'host': '192.168.0.103',
'password': '******',
'port': 60287
},
'syslog_drain_url': null,
'label': 'p-redis',
'provider': null,
'plan': 'shared-vm',
'name': 'myRedisService1',
'tags': [
'pivotal',
'redis'
]
},
{
'credentials': {
'host': '192.168.0.103',
'password': '******',
'port': 60287
},
'syslog_drain_url': null,
'label': 'p-redis',
'provider': null,
'plan': 'shared-vm',
'name': 'myRedisService2',
'tags': [
'pivotal',
'redis'
]
}
]
}
";
// Arrange
IServiceCollection services = new ServiceCollection();
Environment.SetEnvironmentVariable("VCAP_APPLICATION", env1);
Environment.SetEnvironmentVariable("VCAP_SERVICES", env2);
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddCloudFoundry();
var config = builder.Build();
// Act and Assert
var ex = Assert.Throws <ConnectorException>(() => RedisCacheServiceCollectionExtensions.AddDistributedRedisCache(services, config));
Assert.Contains("Multiple", ex.Message);
}
