public void Constructor_BindsValues() { var appsettings = @" { 'redis': { 'client': { 'host': 'localhost', 'port': 1234, 'password': '******', 'instanceid': 'instanceid' } } }"; 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(); var sconfig = new RedisCacheConnectorOptions(config); Assert.Equal("localhost", sconfig.Host); Assert.Equal(1234, sconfig.Port); Assert.Equal("password", sconfig.Password); Assert.Equal("instanceid", sconfig.InstanceId); Assert.Equal(null, sconfig.ConnectionString); }
public void CreateRedisServiceConnectorFactory_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(); RedisCacheConnectorOptions connectorOptions = new RedisCacheConnectorOptions(); // Act and Assert var ex = Assert.Throws <ConnectorException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config)); Assert.Contains("Multiple", ex.Message); var ex2 = Assert.Throws <ConnectorException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, config)); Assert.Contains("Multiple", ex2.Message); var ex3 = Assert.Throws <ConnectorException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, connectorOptions)); Assert.Contains("Multiple", ex3.Message); }
public void Create_CanReturnRedisCache() { // arrange RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceName = "instanceId" }; RedisServiceInfo si = new RedisServiceInfo("myId", RedisServiceInfo.REDIS_SCHEME, "foobar", 4321, "sipassword") { ApplicationInfo = new ApplicationInstanceInfo() { InstanceId = "instanceId" } }; // act var factory = new RedisServiceConnectorFactory(si, config, typeof(RedisCache), typeof(RedisCacheOptions), null); var cache = factory.Create(null); // assert Assert.NotNull(cache); Assert.IsType <RedisCache>(cache); }
public void ConnectionString_Overridden_By_CloudFoundryConfig() { // arrange // simulate an appsettings file var appsettings = new Dictionary <string, string>() { ["redis:client:ConnectionString"] = "Server=fake;Database=test;Uid=steeltoe;Pwd=password;" }; // add environment variables as Cloud Foundry would Environment.SetEnvironmentVariable("VCAP_APPLICATION", TestHelpers.VCAP_APPLICATION); Environment.SetEnvironmentVariable("VCAP_SERVICES", RedisCacheTestHelpers.SingleServerVCAP); // add settings to config ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); configurationBuilder.AddInMemoryCollection(appsettings); configurationBuilder.AddEnvironmentVariables(); configurationBuilder.AddCloudFoundry(); var config = configurationBuilder.Build(); // act var sconfig = new RedisCacheConnectorOptions(config); // assert Assert.NotEqual(appsettings["redis:client:ConnectionString"], sconfig.ToString()); }
public void Create_CanReturnConnectionMultiplexer() { // arrange RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceName = "instanceId", AbortOnConnectFail = false, ConnectTimeout = 1 }; RedisServiceInfo si = new RedisServiceInfo("myId", "127.0.0.1", 4321, "sipassword") { ApplicationInfo = new ApplicationInstanceInfo() { InstanceId = "instanceId" } }; MethodInfo initializer = typeof(ConnectionMultiplexer).GetMethod("Connect", new Type[] { typeof(ConfigurationOptions), typeof(TextWriter) }); // act var factory = new RedisServiceConnectorFactory(si, config, typeof(ConnectionMultiplexer), typeof(ConfigurationOptions), initializer); var multi = factory.Create(null); // assert Assert.NotNull(multi); Assert.IsType <ConnectionMultiplexer>(multi); }
public void Create_CanReturnConnectionMultiplexer() { // arrange RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceName = "instanceId", AbortOnConnectFail = false, ConnectTimeout = 1 }; RedisServiceInfo si = new RedisServiceInfo("myId", RedisServiceInfo.REDIS_SCHEME, "127.0.0.1", 4321, "sipassword") { ApplicationInfo = new ApplicationInstanceInfo() { InstanceId = "instanceId" } }; // act var factory = new RedisServiceConnectorFactory(si, config, typeof(ConnectionMultiplexer), typeof(ConfigurationOptions), RedisTypeLocator.StackExchangeInitializer); var multi = factory.Create(null); // assert Assert.NotNull(multi); Assert.IsType <ConnectionMultiplexer>(multi); }
public void ConfigureConnection_NoServiceInfo_ReturnsExpected() { // arrange var configurer = new RedisCacheConfigurer(); var config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******" }; // act var opts = configurer.Configure(null, config); Assert.NotNull(opts); // assert Assert.NotNull(((ConfigurationOptions)opts.ToStackExchangeObject(typeof(ConfigurationOptions))).EndPoints); var ep = ((ConfigurationOptions)opts.ToStackExchangeObject(typeof(ConfigurationOptions))).EndPoints[0] as DnsEndPoint; Assert.NotNull(ep); Assert.Equal("localhost", ep.Host); Assert.Equal(1234, ep.Port); Assert.Equal("password", opts.Password); }
/// <summary> /// Adds ConnectionMultiplexer (as ConnectionMultiplexer and IConnectionMultiplexer) to your Autofac Container /// </summary> /// <param name="container">Your Autofac Container Builder</param> /// <param name="config">Application configuration</param> /// <param name="serviceName">Cloud Foundry service name binding</param> /// <returns>the RegistrationBuilder for (optional) additional configuration</returns> public static IRegistrationBuilder <object, SimpleActivatorData, SingleRegistrationStyle> RegisterRedisConnectionMultiplexer( this ContainerBuilder container, IConfiguration config, string serviceName = null) { if (container == null) { throw new ArgumentNullException(nameof(container)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } Type redisInterface = RedisTypeLocator.StackExchangeInterface; Type redisImplementation = RedisTypeLocator.StackExchangeImplementation; Type redisOptions = RedisTypeLocator.StackExchangeOptions; MethodInfo initializer = RedisTypeLocator.StackExchangeInitializer; RedisServiceInfo info = serviceName != null ? config.GetRequiredServiceInfo <RedisServiceInfo>(serviceName) : config.GetSingletonServiceInfo <RedisServiceInfo>(); RedisCacheConnectorOptions redisConfig = new RedisCacheConnectorOptions(config); RedisServiceConnectorFactory factory = new RedisServiceConnectorFactory(info, redisConfig, redisImplementation, redisOptions, initializer ?? null); container.Register(c => new RedisHealthContributor(factory, redisImplementation, c.ResolveOptional <ILogger <RedisHealthContributor> >())).As <IHealthContributor>(); return(container.Register(c => factory.Create(null)).As(redisInterface, redisImplementation)); }
public void ConfigureConnection_ServiceInfoOveridesConfig_ReturnsExpected() { // arrange var configurer = new RedisCacheConfigurer(); var config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******" }; var si = new RedisServiceInfo("myId", RedisServiceInfo.REDIS_SCHEME, "foobar", 4321, "sipassword"); // act var opts = configurer.Configure(si, config); Assert.NotNull(opts); // assert Assert.NotNull(((ConfigurationOptions)opts.ToStackExchangeObject(typeof(ConfigurationOptions))).EndPoints); var ep = ((ConfigurationOptions)opts.ToStackExchangeObject(typeof(ConfigurationOptions))).EndPoints[0] as DnsEndPoint; Assert.NotNull(ep); Assert.Equal("foobar", ep.Host); Assert.Equal(4321, ep.Port); Assert.Equal("sipassword", opts.Password); }
public void ConfigureConnection_ServiceInfoOveridesConfig_ReturnsExpected() { RedisCacheConfigurer configurer = new RedisCacheConfigurer(); RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******" }; RedisServiceInfo si = new RedisServiceInfo("myId", "foobar", 4321, "sipassword"); si.ApplicationInfo = new ApplicationInstanceInfo() { InstanceId = "instanceId" }; var opts = configurer.ConfigureConnection(si, config); Assert.NotNull(opts); Assert.NotNull(opts.EndPoints); var ep = opts.EndPoints[0] as DnsEndPoint; Assert.NotNull(ep); Assert.Equal("foobar", ep.Host); Assert.Equal(4321, ep.Port); Assert.Equal("sipassword", opts.Password); }
public void Configure_ServiceInfoOveridesConfig_ReturnsExpected() { RedisCacheConfigurer configurer = new RedisCacheConfigurer(); RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceId = "instanceId" }; RedisServiceInfo si = new RedisServiceInfo("myId", "foobar", 4321, "sipassword"); si.ApplicationInfo = new ApplicationInstanceInfo() { InstanceId = "instanceId" }; var opts = configurer.Configure(si, config); Assert.NotNull(opts); var redisOptions = opts.Value; Assert.NotNull(redisOptions); Assert.Equal("foobar:4321,password=sipassword,allowAdmin=false,abortConnect=true,resolveDns=false,ssl=false", redisOptions.Configuration); Assert.Equal("instanceId", redisOptions.InstanceName); }
public void Constructor_BindsValues() { var appsettings = @" { 'redis': { 'client': { 'host': 'localhost', 'port': 1234, 'password': '******', 'instanceid': 'instanceid', 'allowAdmin': true, 'clientName': 'foobar', 'connectRetry': 100, 'connectTimeout': 100, 'abortOnConnectFail': true, 'keepAlive': 100, 'resolveDns': true, 'serviceName': 'foobar', 'ssl': true, 'sslHost': 'foobar', 'writeBuffer': 100, 'tieBreaker': 'foobar' } } }"; 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(); var sconfig = new RedisCacheConnectorOptions(config); Assert.Equal("localhost", sconfig.Host); Assert.Equal(1234, sconfig.Port); Assert.Equal("password", sconfig.Password); Assert.Equal("instanceid", sconfig.InstanceId); Assert.Equal(true, sconfig.AllowAdmin); Assert.Equal("foobar", sconfig.ClientName); Assert.Equal(100, sconfig.ConnectRetry); Assert.Equal(100, sconfig.ConnectTimeout); Assert.Equal(true, sconfig.AbortOnConnectFail); Assert.Equal(100, sconfig.KeepAlive); Assert.Equal(true, sconfig.ResolveDns); Assert.Equal("foobar", sconfig.ServiceName); Assert.Equal(true, sconfig.Ssl); Assert.Equal("foobar", sconfig.SslHost); Assert.Equal("foobar", sconfig.TieBreaker); Assert.Equal(100, sconfig.WriteBuffer); Assert.Equal(null, sconfig.ConnectionString); }
public string GetConnectionString() { var info = configuration.GetSingletonServiceInfo <RedisServiceInfo>(); var redisConfig = new RedisCacheConnectorOptions(configuration); var connectionOptions = new RedisCacheConfigurer().Configure(info, redisConfig); return(connectionOptions.ToString()); }
public void CreateRedisServiceConnectorFactory_ThrowsIfConnectorOptionsNull() { var config = new ConfigurationBuilder().Build(); RedisCacheConnectorOptions connectorOptions = null; var ex = Assert.Throws <ArgumentNullException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, connectorOptions, "foobar")); Assert.Contains(nameof(connectorOptions), ex.Message); }
public void UpdateOptions_FromServiceInfo_ReturnsExcpected() { var configurer = new RedisCacheConfigurer(); var connOptions = new RedisCacheConnectorOptions(); var si = new RedisServiceInfo("myId", RedisServiceInfo.REDIS_SCHEME, "foobar", 4321, "sipassword"); configurer.UpdateOptions(si, connOptions); Assert.Equal("foobar:4321,password=sipassword,allowAdmin=false,abortConnect=true,resolveDns=false,ssl=false", connOptions.ToString()); Assert.Null(connOptions.InstanceName); }
public void Microsoft_Is_Connected_Returns_Up_Status() { var redisOptions = new RedisCacheConnectorOptions(); var sInfo = new RedisServiceInfo("MyId", "redis://localhost:6379"); var logrFactory = new LoggerFactory(); var connFactory = new RedisServiceConnectorFactory(sInfo, redisOptions, RedisTypeLocator.MicrosoftImplementation, RedisTypeLocator.MicrosoftOptions, null); var h = new RedisHealthContributor(connFactory, RedisTypeLocator.MicrosoftImplementation, logrFactory.CreateLogger <RedisHealthContributor>()); var status = h.Health(); Assert.Equal(HealthStatus.UP, status.Status); }
public void Constructor_BindsValues() { var appsettings = new Dictionary <string, string>() { ["redis:client:host"] = "localhost", ["redis:client:port"] = "1234", ["redis:client:password"] = "******", ["redis:client:instancename"] = "instanceid", ["redis:client:allowAdmin"] = "true", ["redis:client:clientName"] = "foobar", ["redis:client:connectRetry"] = "100", ["redis:client:connectTimeout"] = "100", ["redis:client:abortOnConnectFail"] = "true", ["redis:client:keepAlive"] = "100", ["redis:client:resolveDns"] = "true", ["redis:client:serviceName"] = "foobar", ["redis:client:ssl"] = "true", ["redis:client:sslHost"] = "foobar", ["redis:client:writeBuffer"] = "100", ["redis:client:tieBreaker"] = "foobar", ["redis:client:syncTimeout"] = "100" }; ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); configurationBuilder.AddInMemoryCollection(appsettings); var config = configurationBuilder.Build(); var sconfig = new RedisCacheConnectorOptions(config); Assert.Equal("localhost", sconfig.Host); Assert.Equal(1234, sconfig.Port); Assert.Equal("password", sconfig.Password); Assert.Equal("instanceid", sconfig.InstanceName); Assert.True(sconfig.AllowAdmin); Assert.Equal("foobar", sconfig.ClientName); Assert.Equal(100, sconfig.ConnectRetry); Assert.Equal(100, sconfig.ConnectTimeout); Assert.True(sconfig.AbortOnConnectFail); Assert.Equal(100, sconfig.KeepAlive); Assert.True(sconfig.ResolveDns); Assert.Equal("foobar", sconfig.ServiceName); Assert.True(sconfig.Ssl); Assert.Equal("foobar", sconfig.SslHost); Assert.Equal("foobar", sconfig.TieBreaker); Assert.Equal(100, sconfig.WriteBuffer); Assert.Equal(100, sconfig.SyncTimeout); Assert.Null(sconfig.ConnectionString); }
public void ConnectionString_Returned_AsConfigured() { var appsettings = new Dictionary <string, string>() { ["redis:client:ConnectionString"] = "Server=fake;Database=test;Uid=steeltoe;Pwd=password;" }; var configurationBuilder = new ConfigurationBuilder(); configurationBuilder.AddInMemoryCollection(appsettings); var config = configurationBuilder.Build(); var sconfig = new RedisCacheConnectorOptions(config); Assert.Equal(appsettings["redis:client:ConnectionString"], sconfig.ToString()); }
public void StackExchange_Is_Connected_Returns_Up_Status() { // arrange var redisOptions = new RedisCacheConnectorOptions(); var sInfo = new RedisServiceInfo("MyId", "redis://localhost:6379"); var logrFactory = new LoggerFactory(); var connFactory = new RedisServiceConnectorFactory(sInfo, redisOptions, RedisTypeLocator.StackExchangeImplementation, RedisTypeLocator.StackExchangeOptions, RedisTypeLocator.StackExchangeInitializer); var h = new RedisHealthContributor(connFactory, RedisTypeLocator.StackExchangeImplementation, logrFactory.CreateLogger <RedisHealthContributor>()); // act var status = h.Health(); // assert Assert.Equal(HealthStatus.UP, status.Status); }
public void UpdateOptions_FromServiceInfo_ReturnsExcpected() { RedisCacheConfigurer configurer = new RedisCacheConfigurer(); RedisCacheConnectorOptions connOptions = new RedisCacheConnectorOptions(); RedisServiceInfo si = new RedisServiceInfo("myId", "foobar", 4321, "sipassword"); si.ApplicationInfo = new ApplicationInstanceInfo() { ApplicationId = "applicationId" }; configurer.UpdateOptions(si, connOptions); Assert.Equal("foobar:4321,password=sipassword,allowAdmin=false,abortConnect=true,resolveDns=false,ssl=false", connOptions.ToString()); Assert.Null(connOptions.InstanceId); }
public void UpdateOptions_FromConfig_WithConnectionString_ReturnsExcpected() { RedisCacheConfigurer configurer = new RedisCacheConfigurer(); RedisCacheOptions redisOptions = new RedisCacheOptions(); RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { ConnectionString = "foobar", InstanceId = "instanceId" }; configurer.UpdateOptions(config, redisOptions); Assert.Equal("foobar", redisOptions.Configuration); Assert.Equal("instanceId", redisOptions.InstanceName); }
public void Microsoft_Not_Connected_Returns_Down_Status() { var redisOptions = new RedisCacheConnectorOptions() { ConnectTimeout = 1 }; var sInfo = new RedisServiceInfo("MyId", "redis://localhost:6378"); var logrFactory = new LoggerFactory(); var connFactory = new RedisServiceConnectorFactory(sInfo, redisOptions, RedisTypeLocator.MicrosoftImplementation, RedisTypeLocator.MicrosoftOptions, null); var h = new RedisHealthContributor(connFactory, RedisTypeLocator.MicrosoftImplementation, logrFactory.CreateLogger <RedisHealthContributor>()); var status = h.Health(); Assert.Equal(HealthStatus.DOWN, status.Status); Assert.Equal("Redis health check failed", status.Description); }
public void UpdateOptions_FromConfig_WithOutConnectionString_ReturnsExcpected() { RedisCacheConfigurer configurer = new RedisCacheConfigurer(); RedisCacheOptions redisOptions = new RedisCacheOptions(); RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceId = "instanceId" }; configurer.UpdateOptions(config, redisOptions); Assert.Equal("localhost:1234,password=password,allowAdmin=false,abortConnect=true,resolveDns=false,ssl=false", redisOptions.Configuration); Assert.Equal("instanceId", redisOptions.InstanceName); }
public void CreateRedisServiceConnectorFactory_ThrowsIfConfigurationNull() { // Arrange IConfigurationRoot config = null; IConfigurationRoot connectorConfiguration = new ConfigurationBuilder().Build(); RedisCacheConnectorOptions connectorOptions = new RedisCacheConnectorOptions(); // Act and Assert var ex = Assert.Throws<ArgumentNullException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, "foobar")); Assert.Contains(nameof(config), ex.Message); var ex2 = Assert.Throws<ArgumentNullException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, connectorConfiguration, "foobar")); Assert.Contains(nameof(config), ex2.Message); var ex3 = Assert.Throws<ArgumentNullException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, connectorOptions, "foobar")); Assert.Contains(nameof(config), ex3.Message); }
public void CreateRedisServiceConnectorFactory_WithServiceName_NoVCAPs_ThrowsConnectorException() { // Arrange IServiceCollection services = new ServiceCollection(); IConfigurationRoot config = new ConfigurationBuilder().Build(); RedisCacheConnectorOptions connectorOptions = new RedisCacheConnectorOptions(); // Act and Assert var ex = Assert.Throws<ConnectorException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, "foobar")); Assert.Contains("foobar", ex.Message); var ex2 = Assert.Throws<ConnectorException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, config, "foobar")); Assert.Contains("foobar", ex2.Message); var ex3 = Assert.Throws<ConnectorException>(() => RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config, connectorOptions, "foobar")); Assert.Contains("foobar", ex3.Message); }
public void Configure_ServiceInfoOveridesConfig_ReturnsExpected() { var configurer = new RedisCacheConfigurer(); var config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceName = "instanceId" }; var si = new RedisServiceInfo("myId", RedisServiceInfo.REDIS_SCHEME, "foobar", 4321, "sipassword"); var connectionSettings = configurer.Configure(si, config); Assert.NotNull(connectionSettings); Assert.Equal("foobar:4321,password=sipassword,allowAdmin=false,abortConnect=true,resolveDns=false,ssl=false", connectionSettings.ToString()); Assert.Equal("instanceId", connectionSettings.InstanceName); }
public void Configure_NoServiceInfo_ReturnsExpected() { var configurer = new RedisCacheConfigurer(); var config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceName = "instanceId" }; var opts = configurer.Configure(null, config); Assert.NotNull(opts); var redisOptions = (RedisCacheOptions)opts.ToMicrosoftExtensionObject(typeof(RedisCacheOptions)); Assert.NotNull(redisOptions); Assert.Equal("localhost:1234,password=password,allowAdmin=false,abortConnect=true,resolveDns=false,ssl=false", redisOptions.Configuration); Assert.Equal("instanceId", redisOptions.InstanceName); }
public void Configure_NoServiceInfo_ReturnsExpected() { RedisCacheConfigurer configurer = new RedisCacheConfigurer(); RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceId = "instanceId" }; var opts = configurer.Configure(null, config); Assert.NotNull(opts); var redisOptions = opts.Value; Assert.NotNull(redisOptions); Assert.Equal("localhost:1234,password=password", redisOptions.Configuration); Assert.Equal("instanceId", redisOptions.InstanceName); }
public void CreateCache_ReturnsRedisCache() { RedisCacheConnectorOptions config = new RedisCacheConnectorOptions() { Host = "localhost", Port = 1234, Password = "******", InstanceId = "instanceId" }; RedisServiceInfo si = new RedisServiceInfo("myId", "foobar", 4321, "sipassword"); si.ApplicationInfo = new ApplicationInstanceInfo() { InstanceId = "instanceId" }; var factory = new RedisServiceConnectorFactory(si, config); var cache = factory.CreateCache(null); Assert.NotNull(cache); }
public void CreateRedisServiceConnectorFactory_NoVCAPs_CreatesFactory() { var appsettings = new Dictionary <string, string>() { ["redis:client:host"] = "127.0.0.1", ["redis:client:port"] = "1234", ["redis:client:password"] = "******", ["redis:client:abortOnConnectFail"] = "false" }; var configurationBuilder = new ConfigurationBuilder(); configurationBuilder.AddInMemoryCollection(appsettings); var config = configurationBuilder.Build(); var connectorOptions = new RedisCacheConnectorOptions(config); Assert.NotNull(RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(config)); Assert.NotNull(RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(new ConfigurationBuilder().Build(), config)); Assert.NotNull(RedisCacheConfigurationExtensions.CreateRedisServiceConnectorFactory(new ConfigurationBuilder().Build(), connectorOptions)); }