DATAREDIS-574 - Introduce dedicated RedisClientConfiguration for Jedis & Lettuce.

We added Jedis-/LettuceClientConfiguration and mutable Jedis-/LettuceClientConfiguration to encapsulate Jedis/Lettuce specific client features. Those should be used for ConnectionFactory configuration.

Additionally we added RedisStandaloneConfiguration next to the existing configurations for Sentinel and Cluster.

Along the way we also removed superfluous test system properties and Gemfire specific hooks and truststore customization.

Original Pull Request: #236

src/test/java/org/springframework/data/redis/ConnectionFactoryTracker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,9 @@
  */
 package org.springframework.data.redis;
 
+import java.util.ArrayList;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Set;
 
 import org.springframework.beans.factory.DisposableBean;
@@ -26,6 +28,7 @@ import org.springframework.data.redis.connection.RedisConnectionFactory;
  * factory during setup and then call {@link #cleanUp()} through the <tt>@AfterClass</tt> method.
  *
  * @author Costin Leau
+ * @author Mark Paluch
  */
 public abstract class ConnectionFactoryTracker {
 
@@ -41,12 +44,14 @@ public abstract class ConnectionFactoryTracker {
 
 	public static void cleanUp() {
 		if (connFactories != null) {
-			for (Object connectionFactory : connFactories) {
+			List<Object> copy = new ArrayList<>(connFactories);
+			for (Object connectionFactory : copy) {
 				try {
 					if (connectionFactory instanceof DisposableBean) {
 						((DisposableBean) connectionFactory).destroy();
 						// System.out.println("Succesfully cleaned up factory " + connectionFactory);
 					}
+					connFactories.remove(connectionFactory);
 				} catch (Exception ex) {
 					System.err.println("Cannot clean factory " + connectionFactory + ex);
 				}

src/test/java/org/springframework/data/redis/connection/jedis/JedisClientConfigurationUnitTests.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.redis.connection.jedis;
+
+import static org.assertj.core.api.Assertions.*;
+
+import redis.clients.jedis.JedisPoolConfig;
+
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocketFactory;
+
+import org.junit.Test;
+
+/**
+ * Unit tests for {@link JedisClientConfiguration}.
+ *
+ * @author Mark Paluch
+ */
+public class JedisClientConfigurationUnitTests {
+
+	@Test // DATAREDIS-574
+	public void shouldCreateEmptyConfiguration() {
+
+		JedisClientConfiguration configuration = JedisClientConfiguration.create();
+
+		assertThat(configuration.getClientName()).isEmpty();
+		assertThat(configuration.getConnectTimeout()).isEqualTo(Duration.ofSeconds(2));
+		assertThat(configuration.getReadTimeout()).isEqualTo(Duration.ofSeconds(2));
+		assertThat(configuration.getHostnameVerifier()).isEmpty();
+		assertThat(configuration.getPoolConfig()).isPresent();
+		assertThat(configuration.getSslParameters()).isEmpty();
+		assertThat(configuration.getSslSocketFactory()).isEmpty();
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldConfigureAllProperties() throws NoSuchAlgorithmException {
+
+		SSLParameters sslParameters = new SSLParameters();
+		SSLContext context = SSLContext.getDefault();
+		SSLSocketFactory socketFactory = context.getSocketFactory();
+		JedisPoolConfig poolConfig = new JedisPoolConfig();
+
+		JedisClientConfiguration configuration = JedisClientConfiguration.builder().useSsl() //
+				.hostnameVerifier(MyHostnameVerifier.INSTANCE) //
+				.sslParameters(sslParameters) //
+				.sslSocketFactory(socketFactory).and() //
+				.clientName("my-client") //
+				.connectTimeout(Duration.ofMinutes(10)) //
+				.readTimeout(Duration.ofHours(5)) //
+				.usePooling().poolConfig(poolConfig) //
+				.build();
+
+		assertThat(configuration.useSsl()).isTrue();
+		assertThat(configuration.getHostnameVerifier()).contains(MyHostnameVerifier.INSTANCE);
+		assertThat(configuration.getSslParameters()).contains(sslParameters);
+		assertThat(configuration.getSslSocketFactory()).contains(socketFactory);
+
+		assertThat(configuration.getClientName()).contains("my-client");
+		assertThat(configuration.getConnectTimeout()).isEqualTo(Duration.ofMinutes(10));
+		assertThat(configuration.getReadTimeout()).isEqualTo(Duration.ofHours(5));
+
+		assertThat(configuration.getPoolConfig()).contains(poolConfig);
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldAllowsConfigurationOverrides() {
+
+		JedisClientConfiguration configuration = JedisClientConfiguration.builder().useSsl() //
+				.and().usePlaintext() //
+				.usePooling().and().useUnpooledConnections() //
+				.build();
+
+		assertThat(configuration.useSsl()).isFalse();
+		assertThat(configuration.usePooling()).isFalse();
+	}
+
+	enum MyHostnameVerifier implements HostnameVerifier {
+
+		INSTANCE;
+
+		@Override
+		public boolean verify(String s, SSLSession sslSession) {
+			return false;
+		}
+	}
+}

src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionFactoryIntegrationTests.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.redis.connection.jedis;
+
+import static org.hamcrest.core.IsEqual.*;
+import static org.junit.Assert.*;
+
+import redis.clients.jedis.JedisShardInfo;
+
+import org.junit.After;
+import org.junit.Test;
+import org.springframework.data.redis.SettingsUtils;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+
+/**
+ * Integration tests for {@link JedisConnectionFactory}.
+ *
+ * @author Mark Paluch
+ */
+public class JedisConnectionFactoryIntegrationTests {
+
+	private JedisConnectionFactory factory;
+
+	@After
+	public void tearDown() {
+
+		if (factory != null) {
+			factory.destroy();
+		}
+	}
+
+	@Test // DATAREDIS-574
+	public void shardInfoShouldOverrideFactorySettings() {
+
+		factory = new JedisConnectionFactory(new JedisShardInfo(SettingsUtils.getHost(), SettingsUtils.getPort()));
+		factory.setUsePool(false);
+		factory.setPassword("foo");
+		factory.setHostName("bar");
+		factory.setPort(1234);
+		factory.afterPropertiesSet();
+
+		assertThat(factory.getConnection().ping(), equalTo("PONG"));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldInitiaizeWithStandaloneConfiguration() {
+
+		factory = new JedisConnectionFactory(
+				new RedisStandaloneConfiguration(SettingsUtils.getHost(), SettingsUtils.getPort()),
+				JedisClientConfiguration.create());
+		factory.afterPropertiesSet();
+
+		assertThat(factory.getConnection().ping(), equalTo("PONG"));
+	}
+}

src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionFactorySentinelIntegrationTests.java

@@ -19,17 +19,19 @@ import static org.hamcrest.core.IsEqual.*;
 import static org.junit.Assert.*;
 
 import org.junit.After;
-import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
 import org.springframework.data.redis.test.util.RedisSentinelRule;
 
 /**
+ * Sentinel integration tests for {@link JedisConnectionFactory}.
+ *
  * @author Christoph Strobl
  * @author Fu Jian
+ * @author Mark Paluch
  */
-public class JedisConnectionFactoryTests {
+public class JedisConnectionFactorySentinelIntegrationTests {
 
 	private static final RedisSentinelConfiguration SENTINEL_CONFIG = new RedisSentinelConfiguration().master("mymaster")
 			.sentinel("127.0.0.1", 26379).sentinel("127.0.0.1", 26380);
@@ -37,25 +39,43 @@ public class JedisConnectionFactoryTests {
 
 	public @Rule RedisSentinelRule sentinelRule = RedisSentinelRule.forConfig(SENTINEL_CONFIG).oneActive();
 
-	@Before
-	public void setUp() {
-		factory = new JedisConnectionFactory(SENTINEL_CONFIG);
-		factory.setClientName("clientName");
-		factory.afterPropertiesSet();
-	}
-
 	@After
 	public void tearDown() {
-		factory.destroy();
+
+		if (factory != null) {
+			factory.destroy();
+		}
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldInitiaizeWithSentinelConfiguration() {
+
+		JedisClientConfiguration clientConfiguration = JedisClientConfiguration.builder() //
+				.clientName("clientName") //
+				.build();
+
+		factory = new JedisConnectionFactory(SENTINEL_CONFIG, clientConfiguration);
+		factory.afterPropertiesSet();
+
+		assertThat(factory.getConnection().getClientName(), equalTo("clientName"));
 	}
 
 	@Test // DATAREDIS-324
 	public void shouldSendCommandCorrectlyViaConnectionFactoryUsingSentinel() {
+
+		factory = new JedisConnectionFactory(SENTINEL_CONFIG);
+		factory.afterPropertiesSet();
+
 		assertThat(factory.getConnection().ping(), equalTo("PONG"));
 	}
 
 	@Test // DATAREDIS-552
 	public void getClientNameShouldEqualWithFactorySetting() {
+
+		factory = new JedisConnectionFactory(SENTINEL_CONFIG);
+		factory.setClientName("clientName");
+		factory.afterPropertiesSet();
+
 		assertThat(factory.getConnection().getClientName(), equalTo("clientName"));
 	}
 }

src/test/java/org/springframework/data/redis/connection/jedis/JedisConnectionFactoryUnitTests.java

@@ -15,31 +15,44 @@
  */
 package org.springframework.data.redis.connection.jedis;
 
+import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
+import redis.clients.jedis.JedisCluster;
+import redis.clients.jedis.JedisPoolConfig;
+import sun.net.www.protocol.https.DefaultHostnameVerifier;
+
 import java.io.IOException;
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocketFactory;
 
 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.junit.Test;
 import org.springframework.data.redis.connection.RedisClusterConfiguration;
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
 import org.springframework.test.util.ReflectionTestUtils;
 
-import redis.clients.jedis.JedisCluster;
-import redis.clients.jedis.JedisPoolConfig;
-
 /**
+ * Unit tests for {@link JedisConnectionFactory}.
+ *
  * @author Christoph Strobl
+ * @author Mark Paluch
  */
 public class JedisConnectionFactoryUnitTests {
 
 	private JedisConnectionFactory connectionFactory;
 
-	private static final RedisSentinelConfiguration SINGLE_SENTINEL_CONFIG = new RedisSentinelConfiguration().master(
-			"mymaster").sentinel("127.0.0.1", 26379);
+	private static final RedisSentinelConfiguration SINGLE_SENTINEL_CONFIG = new RedisSentinelConfiguration()
+			.master("mymaster").sentinel("127.0.0.1", 26379);
 
-	private static final RedisClusterConfiguration CLUSTER_CONFIG = new RedisClusterConfiguration().clusterNode(
-			"127.0.0.1", 6379).clusterNode("127.0.0.1", 6380);
+	private static final RedisClusterConfiguration CLUSTER_CONFIG = new RedisClusterConfiguration()
+			.clusterNode("127.0.0.1", 6379).clusterNode("127.0.0.1", 6380);
 
 	@Test // DATAREDIS-324
 	public void shouldInitSentinelPoolWhenSentinelConfigPresent() {
@@ -73,7 +86,7 @@ public class JedisConnectionFactoryUnitTests {
 	}
 
 	@Test // DATAREDIS-315
-	public void shouldClostClusterCorrectlyOnFactoryDestruction() throws IOException {
+	public void shouldCloseClusterCorrectlyOnFactoryDestruction() throws IOException {
 
 		JedisCluster clusterMock = mock(JedisCluster.class);
 		JedisConnectionFactory factory = new JedisConnectionFactory();
@@ -84,6 +97,196 @@ public class JedisConnectionFactoryUnitTests {
 		verify(clusterMock, times(1)).close();
 	}
 
+	@Test // DATAREDIS-574
+	public void shouldReadStandalonePassword() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setPassword("foo");
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getPassword()).isEqualTo("foo");
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteStandalonePassword() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setPassword("foo");
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+		connectionFactory.setPassword("bar");
+
+		assertThat(connectionFactory.getPassword()).isEqualTo("bar");
+		assertThat(envConfig.getPassword()).isEqualTo("bar");
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadSentinelPassword() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setPassword("foo");
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getPassword()).isEqualTo("foo");
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteSentinelPassword() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setPassword("foo");
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+		connectionFactory.setPassword("bar");
+
+		assertThat(connectionFactory.getPassword()).isEqualTo("bar");
+		assertThat(envConfig.getPassword()).isEqualTo("bar");
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadClusterPassword() {
+
+		RedisClusterConfiguration envConfig = new RedisClusterConfiguration();
+		envConfig.setPassword("foo");
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getPassword()).isEqualTo("foo");
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteClusterPassword() {
+
+		RedisClusterConfiguration envConfig = new RedisClusterConfiguration();
+		envConfig.setPassword("foo");
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+		connectionFactory.setPassword("bar");
+
+		assertThat(connectionFactory.getPassword()).isEqualTo("bar");
+		assertThat(envConfig.getPassword()).isEqualTo("bar");
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadStandaloneDatabaseIndex() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setDatabase(2);
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getDatabase()).isEqualTo(2);
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteStandaloneDatabaseIndex() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setDatabase(2);
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+		connectionFactory.setDatabase(3);
+
+		assertThat(connectionFactory.getDatabase()).isEqualTo(3);
+		assertThat(envConfig.getDatabase()).isEqualTo(3);
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadSentinelDatabaseIndex() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setDatabase(2);
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getDatabase()).isEqualTo(2);
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteSentinelDatabaseIndex() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setDatabase(2);
+
+		connectionFactory = new JedisConnectionFactory(envConfig, JedisClientConfiguration.create());
+		connectionFactory.setDatabase(3);
+
+		assertThat(connectionFactory.getDatabase()).isEqualTo(3);
+		assertThat(envConfig.getDatabase()).isEqualTo(3);
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldApplyClientConfiguration() throws NoSuchAlgorithmException {
+
+		SSLParameters sslParameters = new SSLParameters();
+		SSLContext context = SSLContext.getDefault();
+		SSLSocketFactory socketFactory = context.getSocketFactory();
+		JedisPoolConfig poolConfig = new JedisPoolConfig();
+
+		JedisClientConfiguration configuration = JedisClientConfiguration.builder().useSsl() //
+				.hostnameVerifier(new DefaultHostnameVerifier()) //
+				.sslParameters(sslParameters) //
+				.sslSocketFactory(socketFactory).and() //
+				.clientName("my-client") //
+				.connectTimeout(Duration.of(10, ChronoUnit.MINUTES)) //
+				.readTimeout(Duration.of(5, ChronoUnit.DAYS)) //
+				.usePooling().poolConfig(poolConfig) //
+				.build();
+
+		connectionFactory = new JedisConnectionFactory(new RedisStandaloneConfiguration(), configuration);
+
+		assertThat(connectionFactory.getClientConfiguration()).isSameAs(configuration);
+		assertThat(connectionFactory.isUseSsl()).isTrue();
+		assertThat(connectionFactory.getClientName()).isEqualTo("my-client");
+		assertThat(connectionFactory.getTimeout()).isEqualTo((int) Duration.of(5, ChronoUnit.DAYS).toMillis());
+		assertThat(connectionFactory.getUsePool()).isTrue();
+		assertThat(connectionFactory.getPoolConfig()).isSameAs(poolConfig);
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReturnStandaloneConfiguration() {
+
+		RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
+		connectionFactory = new JedisConnectionFactory(configuration, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getStandaloneConfiguration()).isSameAs(configuration);
+		assertThat(connectionFactory.getSentinelConfiguration()).isNull();
+		assertThat(connectionFactory.getClusterConfiguration()).isNull();
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReturnSentinelConfiguration() {
+
+		RedisSentinelConfiguration configuration = new RedisSentinelConfiguration();
+		connectionFactory = new JedisConnectionFactory(configuration, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getStandaloneConfiguration()).isNotNull();
+		assertThat(connectionFactory.getSentinelConfiguration()).isSameAs(configuration);
+		assertThat(connectionFactory.getClusterConfiguration()).isNull();
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReturnClusterConfiguration() {
+
+		RedisClusterConfiguration configuration = new RedisClusterConfiguration();
+		connectionFactory = new JedisConnectionFactory(configuration, JedisClientConfiguration.create());
+
+		assertThat(connectionFactory.getStandaloneConfiguration()).isNotNull();
+		assertThat(connectionFactory.getSentinelConfiguration()).isNull();
+		assertThat(connectionFactory.getClusterConfiguration()).isSameAs(configuration);
+	}
+
+	@Test(expected = IllegalStateException.class) // DATAREDIS-574
+	public void shouldDenyChangesToImmutableClientConfiguration() throws NoSuchAlgorithmException {
+
+		connectionFactory = new JedisConnectionFactory(new RedisStandaloneConfiguration(),
+				JedisClientConfiguration.create());
+
+		connectionFactory.setClientName("foo");
+	}
+
 	private JedisConnectionFactory initSpyedConnectionFactory(RedisSentinelConfiguration sentinelConfig,
 			JedisPoolConfig poolConfig) {
 

src/test/java/org/springframework/data/redis/connection/lettuce/LettuceClientConfigurationUnitTests.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.redis.connection.lettuce;
+
+import static org.assertj.core.api.Assertions.*;
+
+import io.lettuce.core.ClientOptions;
+import io.lettuce.core.resource.ClientResources;
+
+import java.time.Duration;
+
+import org.junit.Test;
+
+/**
+ * Unit tests for {@link LettuceClientConfiguration}.
+ *
+ * @author Mark Paluch
+ */
+public class LettuceClientConfigurationUnitTests {
+
+	@Test // DATAREDIS-574
+	public void shouldCreateEmptyConfiguration() {
+
+		LettuceClientConfiguration configuration = LettuceClientConfiguration.create();
+
+		assertThat(configuration.useSsl()).isFalse();
+		assertThat(configuration.isVerifyPeer()).isTrue();
+		assertThat(configuration.isStartTls()).isFalse();
+		assertThat(configuration.getClientOptions()).isEmpty();
+		assertThat(configuration.getClientResources()).isEmpty();
+		assertThat(configuration.getTimeout()).isEqualTo(Duration.ofSeconds(60));
+		assertThat(configuration.getShutdownTimeout()).isEqualTo(Duration.ofSeconds(2));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldConfigureAllProperties() {
+
+		ClientOptions clientOptions = ClientOptions.create();
+		ClientResources sharedClientResources = LettuceTestClientResources.getSharedClientResources();
+
+		LettuceClientConfiguration configuration = LettuceClientConfiguration.builder() //
+				.useSsl() //
+				.verifyPeer(false) //
+				.startTls().and() //
+				.clientOptions(clientOptions) //
+				.clientResources(sharedClientResources) //
+				.timeout(Duration.ofMinutes(5)) //
+				.shutdownTimeout(Duration.ofHours(2)) //
+				.build();
+
+		assertThat(configuration.useSsl()).isTrue();
+		assertThat(configuration.isVerifyPeer()).isFalse();
+		assertThat(configuration.isStartTls()).isTrue();
+		assertThat(configuration.getClientOptions()).contains(clientOptions);
+		assertThat(configuration.getClientResources()).contains(sharedClientResources);
+		assertThat(configuration.getTimeout()).isEqualTo(Duration.ofMinutes(5));
+		assertThat(configuration.getShutdownTimeout()).isEqualTo(Duration.ofHours(2));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldAllowsConfigurationOverrides() {
+
+		LettuceClientConfiguration configuration = LettuceClientConfiguration.builder() //
+				.useSsl().and().usePlaintext() //
+				.build();
+
+		assertThat(configuration.useSsl()).isFalse();
+	}
+}

src/test/java/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactoryUnitTests.java

@@ -18,16 +18,21 @@ package org.springframework.data.redis.connection.lettuce;
 import static org.hamcrest.core.Is.*;
 import static org.hamcrest.core.IsEqual.*;
 import static org.hamcrest.core.IsInstanceOf.*;
+import static org.hamcrest.core.IsNull.*;
 import static org.junit.Assert.*;
 import static org.springframework.data.redis.connection.ClusterTestVariables.*;
 import static org.springframework.data.redis.connection.lettuce.LettuceTestClientResources.*;
 import static org.springframework.test.util.ReflectionTestUtils.*;
 
 import io.lettuce.core.AbstractRedisClient;
+import io.lettuce.core.ClientOptions;
 import io.lettuce.core.RedisClient;
 import io.lettuce.core.RedisURI;
 import io.lettuce.core.cluster.RedisClusterClient;
+import io.lettuce.core.resource.ClientResources;
 
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
 import java.util.Collections;
 import java.util.concurrent.TimeUnit;
 
@@ -37,8 +42,11 @@ import org.junit.Test;
 import org.springframework.data.redis.ConnectionFactoryTracker;
 import org.springframework.data.redis.connection.RedisClusterConfiguration;
 import org.springframework.data.redis.connection.RedisSentinelConfiguration;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
 
 /**
+ * Unit tests for {@link LettuceConnectionFactory}.
+ *
  * @author Christoph Strobl
  * @author Mark Paluch
  * @author Balázs Németh
@@ -275,4 +283,208 @@ public class LettuceConnectionFactoryUnitTests {
 			assertThat(uri.isVerifyPeer(), is(true));
 		}
 	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadStandalonePassword() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setPassword("foo");
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getPassword(), is(equalTo("foo")));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteStandalonePassword() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setPassword("foo");
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+		connectionFactory.setPassword("bar");
+
+		assertThat(connectionFactory.getPassword(), is(equalTo("bar")));
+		assertThat(envConfig.getPassword(), is(equalTo("bar")));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadSentinelPassword() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setPassword("foo");
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getPassword(), is(equalTo("foo")));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteSentinelPassword() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setPassword("foo");
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+		connectionFactory.setPassword("bar");
+
+		assertThat(connectionFactory.getPassword(), is(equalTo("bar")));
+		assertThat(envConfig.getPassword(), is(equalTo("bar")));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadClusterPassword() {
+
+		RedisClusterConfiguration envConfig = new RedisClusterConfiguration();
+		envConfig.setPassword("foo");
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getPassword(), is(equalTo("foo")));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteClusterPassword() {
+
+		RedisClusterConfiguration envConfig = new RedisClusterConfiguration();
+		envConfig.setPassword("foo");
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+		connectionFactory.setPassword("bar");
+
+		assertThat(connectionFactory.getPassword(), is(equalTo("bar")));
+		assertThat(envConfig.getPassword(), is(equalTo("bar")));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadStandaloneDatabaseIndex() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setDatabase(2);
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getDatabase(), is(2));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteStandaloneDatabaseIndex() {
+
+		RedisStandaloneConfiguration envConfig = new RedisStandaloneConfiguration();
+		envConfig.setDatabase(2);
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+		connectionFactory.setDatabase(3);
+
+		assertThat(connectionFactory.getDatabase(), is(3));
+		assertThat(envConfig.getDatabase(), is(3));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReadSentinelDatabaseIndex() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setDatabase(2);
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getDatabase(), is(2));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldWriteSentinelDatabaseIndex() {
+
+		RedisSentinelConfiguration envConfig = new RedisSentinelConfiguration();
+		envConfig.setDatabase(2);
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(envConfig,
+				LettuceClientConfiguration.create());
+		connectionFactory.setDatabase(3);
+
+		assertThat(connectionFactory.getDatabase(), is(3));
+		assertThat(envConfig.getDatabase(), is(3));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldApplyClientConfiguration() {
+
+		ClientOptions clientOptions = ClientOptions.create();
+		ClientResources sharedClientResources = LettuceTestClientResources.getSharedClientResources();
+
+		LettuceClientConfiguration configuration = LettuceClientConfiguration.builder() //
+				.useSsl() //
+				.verifyPeer(false) //
+				.startTls().and() //
+				.clientOptions(clientOptions) //
+				.clientResources(sharedClientResources) //
+				.timeout(Duration.ofMinutes(5)) //
+				.shutdownTimeout(Duration.ofHours(2)) //
+				.build();
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(new RedisStandaloneConfiguration(),
+				configuration);
+
+		assertThat(connectionFactory.getClientConfiguration(), is(configuration));
+
+		assertThat(connectionFactory.isUseSsl(), is(true));
+		assertThat(connectionFactory.isVerifyPeer(), is(false));
+		assertThat(connectionFactory.isStartTls(), is(true));
+		assertThat(connectionFactory.getClientResources(), is(sharedClientResources));
+		assertThat(connectionFactory.getTimeout(), is(Duration.ofMinutes(5).toMillis()));
+		assertThat(connectionFactory.getShutdownTimeout(), is(Duration.ofHours(2).toMillis()));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReturnStandaloneConfiguration() {
+
+		RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getStandaloneConfiguration(), is(configuration));
+		assertThat(connectionFactory.getSentinelConfiguration(), is(nullValue()));
+		assertThat(connectionFactory.getClusterConfiguration(), is(nullValue()));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReturnSentinelConfiguration() {
+
+		RedisSentinelConfiguration configuration = new RedisSentinelConfiguration();
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getStandaloneConfiguration(), is(notNullValue()));
+		assertThat(connectionFactory.getSentinelConfiguration(), is(configuration));
+		assertThat(connectionFactory.getClusterConfiguration(), is(nullValue()));
+	}
+
+	@Test // DATAREDIS-574
+	public void shouldReturnClusterConfiguration() {
+
+		RedisClusterConfiguration configuration = new RedisClusterConfiguration();
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration,
+				LettuceClientConfiguration.create());
+
+		assertThat(connectionFactory.getStandaloneConfiguration(), is(notNullValue()));
+		assertThat(connectionFactory.getSentinelConfiguration(), is(nullValue()));
+		assertThat(connectionFactory.getClusterConfiguration(), is(configuration));
+	}
+
+	@Test(expected = IllegalStateException.class) // DATAREDIS-574
+	public void shouldDenyChangesToImmutableClientConfiguration() throws NoSuchAlgorithmException {
+
+		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(new RedisStandaloneConfiguration(),
+				LettuceClientConfiguration.create());
+
+		connectionFactory.setUseSsl(false);
+	}
 }

src/test/java/org/springframework/data/redis/core/AbstractOperationsTestParams.java

@@ -26,6 +26,7 @@ import org.springframework.data.redis.PersonObjectFactory;
 import org.springframework.data.redis.RawObjectFactory;
 import org.springframework.data.redis.SettingsUtils;
 import org.springframework.data.redis.StringObjectFactory;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
 import org.springframework.data.redis.serializer.GenericToStringSerializer;
@@ -46,6 +47,9 @@ abstract public class AbstractOperationsTestParams {
 	// DATAREDIS-241
 	public static Collection<Object[]> testParams() {
 
+		RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration(SettingsUtils.getHost(),
+				SettingsUtils.getPort());
+
 		ObjectFactory<String> stringFactory = new StringObjectFactory();
 		ObjectFactory<Long> longFactory = new LongObjectFactory();
 		ObjectFactory<Double> doubleFactory = new DoubleObjectFactory();
@@ -60,9 +64,7 @@ abstract public class AbstractOperationsTestParams {
 			throw new RuntimeException("Cannot init XStream", ex);
 		}
 
-		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
-		jedisConnectionFactory.setPort(SettingsUtils.getPort());
-		jedisConnectionFactory.setHostName(SettingsUtils.getHost());
+		JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(standaloneConfiguration);
 		jedisConnectionFactory.afterPropertiesSet();
 
 		RedisTemplate<String, String> stringTemplate = new StringRedisTemplate();

src/test/java/org/springframework/data/redis/core/ReactiveOperationsTestParams.java

@@ -18,6 +18,7 @@ package org.springframework.data.redis.core;
 import static org.springframework.data.redis.connection.ClusterTestVariables.*;
 
 import java.nio.ByteBuffer;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -35,6 +36,8 @@ import org.springframework.data.redis.SettingsUtils;
 import org.springframework.data.redis.StringObjectFactory;
 import org.springframework.data.redis.connection.RedisClusterConfiguration;
 import org.springframework.data.redis.connection.RedisClusterNode;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.connection.lettuce.LettuceTestClientResources;
 import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
@@ -57,6 +60,14 @@ abstract public class ReactiveOperationsTestParams {
 
 	public static Collection<Object[]> testParams() {
 
+		LettuceClientConfiguration clientConfiguration = LettuceClientConfiguration.builder() //
+				.shutdownTimeout(Duration.ZERO) //
+				.clientResources(LettuceTestClientResources.getSharedClientResources()) //
+				.build();
+
+		RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration(SettingsUtils.getHost(),
+				SettingsUtils.getPort());
+
 		ObjectFactory<String> stringFactory = new StringObjectFactory();
 		ObjectFactory<String> clusterKeyStringFactory = new PrefixStringObjectFactory("{u1}.", stringFactory);
 		ObjectFactory<Long> longFactory = new LongObjectFactory();
@@ -72,10 +83,8 @@ abstract public class ReactiveOperationsTestParams {
 			throw new RuntimeException("Cannot init XStream", ex);
 		}
 
-		LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory();
-		lettuceConnectionFactory.setClientResources(LettuceTestClientResources.getSharedClientResources());
-		lettuceConnectionFactory.setPort(SettingsUtils.getPort());
-		lettuceConnectionFactory.setHostName(SettingsUtils.getHost());
+		LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(standaloneConfiguration,
+				clientConfiguration);
 		lettuceConnectionFactory.afterPropertiesSet();
 
 		JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
@@ -137,9 +146,8 @@ abstract public class ReactiveOperationsTestParams {
 
 			ReactiveRedisTemplate<String, String> clusterStringTemplate = null;
 
-			LettuceConnectionFactory lettuceClusterConnectionFactory = new LettuceConnectionFactory(clusterConfiguration);
-			lettuceClusterConnectionFactory.setPort(SettingsUtils.getPort());
-			lettuceClusterConnectionFactory.setHostName(SettingsUtils.getHost());
+			LettuceConnectionFactory lettuceClusterConnectionFactory = new LettuceConnectionFactory(clusterConfiguration,
+					clientConfiguration);
 			lettuceClusterConnectionFactory.afterPropertiesSet();
 
 			clusterStringTemplate = new ReactiveRedisTemplate<>(lettuceClusterConnectionFactory,