Upgrade to Spring 5.0.0.RELEASE and Spring Data GA releases.

build.gradle

@@ -171,11 +171,11 @@ configure(rootProject) {
 
 ext {
 	matrix = [
-			"driver34-mongo20"  : [mongoDriverVersion: "3.4.2", springDataMongoVersion: "2.0.0.M3"],
-			"jedis29-redis20"   : [jedisVersion: "2.9.0", springDataRedisVersion: "2.0.0.M3"],
-			"lettuce5-redis20" :  [lettuceVersion: "5.0.0.M2", springDataRedisVersion: "2.0.0.M3"],
-			"amqp20"            : [springAmqpVersion: "2.0.0.M3"],
-			"spring50"          : [springVersion: "5.0.0.RC1"],
+			"driver34-mongo20"  : [mongoDriverVersion: "3.4.2", springDataMongoVersion: "2.0.0.RELEASE"],
+			"jedis29-redis20"   : [jedisVersion: "2.9.0", springDataRedisVersion: "2.0.0.RELEASE"],
+			"lettuce5-redis20" :  [lettuceVersion: "5.0.0.RELEASE", springDataRedisVersion: "2.0.0.RELEASE"],
+			"amqp20"            : [springAmqpVersion: "2.0.0.RELEASE"],
+			"spring50"          : [springVersion: "5.0.0.RELEASE"],
 			"tomcat85"          : [tomcatVersion: "8.5.13"],
 	]
 }

spring-cloud-spring-service-connector/build.gradle

@@ -1,17 +1,17 @@
 description = 'Service Connectors'
 
 ext {
-	springVersion = "5.0.0.RC1"
+	springVersion = "5.0.0.RELEASE"
 	tomcatVersion = "8.5.13"
 
-	springAmqpVersion = "2.0.0.M3"
+	springAmqpVersion = "2.0.0.RELEASE"
 
-	springDataMongoVersion = "2.0.0.M3"
+	springDataMongoVersion = "2.0.0.RELEASE"
 	mongoDriverVersion = "3.4.2"
 
-	springDataRedisVersion = "2.0.0.M3"
+	springDataRedisVersion = "2.0.0.RELEASE"
 	jedisVersion = "2.9.0"
-	lettuceVersion = "5.0.0.M2"
+	lettuceVersion = "5.0.0.RELEASE"
 
 	mysqlDriverVersion = "6.0.6"
 	mariadbDriverVersion = "1.5.9"

spring-cloud-spring-service-connector/src/main/java/org/springframework/cloud/service/MapServiceConnectionConfigurer.java

@@ -2,6 +2,7 @@ package org.springframework.cloud.service;
 
 import org.springframework.beans.BeanWrapper;
 import org.springframework.beans.BeanWrapperImpl;
+import org.springframework.beans.MutablePropertyValues;
 
 import java.util.Map;
 
@@ -21,7 +22,7 @@ public class MapServiceConnectionConfigurer<SC, SCC extends MapServiceConnectorC
 			Map<String, Object> properties = config.getConnectionProperties();
 			if (properties != null) {
 				BeanWrapper target = new BeanWrapperImpl(serviceConnector);
-				target.setPropertyValues(properties);
+				target.setPropertyValues(new MutablePropertyValues(properties), true);
 			}
 		}
 		return serviceConnector;

spring-cloud-spring-service-connector/src/main/java/org/springframework/cloud/service/keyval/RedisConnectionFactoryConfigurer.java

@@ -1,56 +0,0 @@
-package org.springframework.cloud.service.keyval;
-
-import org.springframework.beans.BeanWrapper;
-import org.springframework.beans.BeanWrapperImpl;
-import org.springframework.cloud.service.MapServiceConnectionConfigurer;
-import org.springframework.cloud.service.MapServiceConnectorConfig;
-import org.springframework.cloud.service.PooledServiceConnectorConfig;
-import org.springframework.cloud.service.ServiceConnectorConfigurer;
-import org.springframework.cloud.service.Util;
-import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
-
-import redis.clients.jedis.JedisPoolConfig;
-
-/**
- * 
- * @author Ramnivas Laddad
- * @author Scott Frederick
- *
- */
-public class RedisConnectionFactoryConfigurer implements ServiceConnectorConfigurer<JedisConnectionFactory, RedisConnectionFactoryConfig> {
-	private MapServiceConnectionConfigurer<JedisConnectionFactory, MapServiceConnectorConfig> mapServiceConnectionConfigurer =
-			new MapServiceConnectionConfigurer<JedisConnectionFactory, MapServiceConnectorConfig>();
-
-	@Override
-	public JedisConnectionFactory configure(JedisConnectionFactory connectionFactory, RedisConnectionFactoryConfig config) {
-		if (config != null) {
-			configurePool(connectionFactory, config);
-			configureConnection(connectionFactory, config);
-		}
-		return connectionFactory;
-	}
-
-	public JedisConnectionFactory configure(JedisConnectionFactory connectionFactory, PooledServiceConnectorConfig config) {
-		if (config != null) {
-			configurePool(connectionFactory, config);
-		}
-		return connectionFactory;
-	}
-
-	private void configurePool(JedisConnectionFactory connectionFactory, PooledServiceConnectorConfig config) {
-		if (config.getPoolConfig() != null) {
-			JedisPoolConfig poolConfig = new JedisPoolConfig();
-			BeanWrapper target = new BeanWrapperImpl(poolConfig);
-			BeanWrapper source = new BeanWrapperImpl(config.getPoolConfig());
-			Util.setCorrespondingProperties(target, source);
-			connectionFactory.setPoolConfig(poolConfig);
-		}
-	}
-
-	private void configureConnection(JedisConnectionFactory connectionFactory, RedisConnectionFactoryConfig config) {
-		if (config.getConnectionProperties() != null) {
-			mapServiceConnectionConfigurer.configure(connectionFactory, config.getConnectionProperties());
-		}
-	}
-
-}

spring-cloud-spring-service-connector/src/main/java/org/springframework/cloud/service/keyval/RedisConnectionFactoryCreator.java

@@ -8,8 +8,14 @@ import org.springframework.cloud.service.ServiceConnectorConfig;
 import org.springframework.cloud.service.ServiceConnectorCreationException;
 import org.springframework.cloud.service.common.RedisServiceInfo;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.RedisPassword;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
+import org.springframework.data.redis.connection.jedis.JedisClientConfiguration.JedisClientConfigurationBuilder;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder;
 
 /**
  * Simplified access to creating Redis service objects.
@@ -19,6 +25,7 @@ import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactor
  * @author Jennifer Hickey
  * @author Thomas Risberg
  * @author Mark Paluch
+ * @author Scott Frederick
  */
 public class RedisConnectionFactoryCreator extends AbstractServiceConnectorCreator<RedisConnectionFactory, RedisServiceInfo> {
 
@@ -27,36 +34,36 @@ public class RedisConnectionFactoryCreator extends AbstractServiceConnectorCreat
 
 	@Override
 	public RedisConnectionFactory create(RedisServiceInfo serviceInfo, ServiceConnectorConfig serviceConnectorConfig) {
+		RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
+		configuration.setHostName(serviceInfo.getHost());
+		configuration.setPort(serviceInfo.getPort());
+		configuration.setPassword(RedisPassword.of(serviceInfo.getPassword()));
 
 		if (hasClass(JEDIS_CLASS_NAME)) {
+			JedisClientConfigurationBuilder builder = JedisClientConfiguration.builder();
 
-			RedisConnectionFactoryConfigurer configurer = new RedisConnectionFactoryConfigurer();
-
-			JedisConnectionFactory connectionFactory = new JedisConnectionFactory();
-			connectionFactory.setHostName(serviceInfo.getHost());
-			connectionFactory.setPort(serviceInfo.getPort());
-			connectionFactory.setPassword(serviceInfo.getPassword());
-
+			RedisJedisClientConfigurer clientConfigurer = new RedisJedisClientConfigurer();
 			if (serviceConnectorConfig instanceof RedisConnectionFactoryConfig) {
-				configurer.configure(connectionFactory, (RedisConnectionFactoryConfig) serviceConnectorConfig);
+				clientConfigurer.configure(builder, (RedisConnectionFactoryConfig) serviceConnectorConfig);
 			} else {
-				configurer.configure(connectionFactory, (PooledServiceConnectorConfig) serviceConnectorConfig);
+				clientConfigurer.configure(builder, (PooledServiceConnectorConfig) serviceConnectorConfig);
 			}
 
+			JedisConnectionFactory connectionFactory = new JedisConnectionFactory(configuration, builder.build());
 			connectionFactory.afterPropertiesSet();
 			return connectionFactory;
 		}
 		else if (hasClass(LETTUCE_CLASS_NAME)) {
+			LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
 
-			RedisLettuceConnectionFactoryConfigurer configurer = new RedisLettuceConnectionFactoryConfigurer();
-
-			LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory();
-			connectionFactory.setHostName(serviceInfo.getHost());
-			connectionFactory.setPort(serviceInfo.getPort());
-			connectionFactory.setPassword(serviceInfo.getPassword());
-
-			configurer.configure(connectionFactory, (RedisConnectionFactoryConfig) serviceConnectorConfig);
+			RedisLettuceClientConfigurer clientConfigurer = new RedisLettuceClientConfigurer();
+			if (serviceConnectorConfig instanceof RedisConnectionFactoryConfig) {
+				clientConfigurer.configure(builder, (RedisConnectionFactoryConfig) serviceConnectorConfig);
+			} else {
+				clientConfigurer.configure(builder, (PooledServiceConnectorConfig) serviceConnectorConfig);
+			}
 
+			LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration, builder.build());
 			connectionFactory.afterPropertiesSet();
 			return connectionFactory;
 		}

spring-cloud-spring-service-connector/src/main/java/org/springframework/cloud/service/keyval/RedisJedisClientConfigurer.java

@@ -0,0 +1,56 @@
+package org.springframework.cloud.service.keyval;
+
+import redis.clients.jedis.JedisPoolConfig;
+
+import org.springframework.beans.BeanWrapper;
+import org.springframework.beans.BeanWrapperImpl;
+import org.springframework.cloud.service.MapServiceConnectionConfigurer;
+import org.springframework.cloud.service.MapServiceConnectorConfig;
+import org.springframework.cloud.service.PooledServiceConnectorConfig;
+import org.springframework.cloud.service.ServiceConnectorConfigurer;
+import org.springframework.cloud.service.Util;
+import org.springframework.data.redis.connection.jedis.JedisClientConfiguration.JedisClientConfigurationBuilder;
+
+/**
+ * 
+ * @author Scott Frederick
+ *
+ */
+public class RedisJedisClientConfigurer implements ServiceConnectorConfigurer<JedisClientConfigurationBuilder, RedisConnectionFactoryConfig> {
+	private MapServiceConnectionConfigurer<JedisClientConfigurationBuilder, MapServiceConnectorConfig> mapClientConfigurer =
+			new MapServiceConnectionConfigurer<JedisClientConfigurationBuilder, MapServiceConnectorConfig>();
+
+	@Override
+	public JedisClientConfigurationBuilder configure(JedisClientConfigurationBuilder clientConfiguration, RedisConnectionFactoryConfig config) {
+		if (config != null) {
+			configurePool(clientConfiguration, config);
+			configureClient(clientConfiguration, config);
+		}
+		return clientConfiguration;
+	}
+
+	public JedisClientConfigurationBuilder configure(JedisClientConfigurationBuilder clientConfiguration, PooledServiceConnectorConfig config) {
+		if (config != null) {
+			configurePool(clientConfiguration, config);
+		}
+		return clientConfiguration;
+	}
+
+	private void configurePool(JedisClientConfigurationBuilder clientConfiguration, PooledServiceConnectorConfig config) {
+		if (config.getPoolConfig() != null) {
+			JedisPoolConfig poolConfig = new JedisPoolConfig();
+			BeanWrapper target = new BeanWrapperImpl(poolConfig);
+			BeanWrapper source = new BeanWrapperImpl(config.getPoolConfig());
+			Util.setCorrespondingProperties(target, source);
+
+			clientConfiguration.usePooling().poolConfig(poolConfig);
+		}
+	}
+
+	private void configureClient(JedisClientConfigurationBuilder clientConfiguration, RedisConnectionFactoryConfig config) {
+		if (config.getConnectionProperties() != null) {
+			mapClientConfigurer.configure(clientConfiguration, config.getConnectionProperties());
+		}
+	}
+
+}

spring-cloud-spring-service-connector/src/main/java/org/springframework/cloud/service/keyval/RedisLettuceClientConfigurer.java

@@ -0,0 +1,56 @@
+package org.springframework.cloud.service.keyval;
+
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder;
+
+import org.springframework.beans.BeanWrapper;
+import org.springframework.beans.BeanWrapperImpl;
+import org.springframework.cloud.service.MapServiceConnectionConfigurer;
+import org.springframework.cloud.service.MapServiceConnectorConfig;
+import org.springframework.cloud.service.PooledServiceConnectorConfig;
+import org.springframework.cloud.service.ServiceConnectorConfigurer;
+import org.springframework.cloud.service.Util;
+
+/**
+ * 
+ * @author Scott Frederick
+ *
+ */
+public class RedisLettuceClientConfigurer implements ServiceConnectorConfigurer<LettucePoolingClientConfigurationBuilder, RedisConnectionFactoryConfig> {
+	private MapServiceConnectionConfigurer<LettucePoolingClientConfigurationBuilder, MapServiceConnectorConfig> mapClientConfigurer =
+			new MapServiceConnectionConfigurer<LettucePoolingClientConfigurationBuilder, MapServiceConnectorConfig>();
+
+	@Override
+	public LettucePoolingClientConfigurationBuilder configure(LettucePoolingClientConfigurationBuilder clientConfiguration, RedisConnectionFactoryConfig config) {
+		if (config != null) {
+			configurePool(clientConfiguration, config);
+			configureClient(clientConfiguration, config);
+		}
+		return clientConfiguration;
+	}
+
+	public LettucePoolingClientConfigurationBuilder configure(LettucePoolingClientConfigurationBuilder clientConfiguration, PooledServiceConnectorConfig config) {
+		if (config != null) {
+			configurePool(clientConfiguration, config);
+		}
+		return clientConfiguration;
+	}
+
+	private void configurePool(LettucePoolingClientConfigurationBuilder clientConfiguration, PooledServiceConnectorConfig config) {
+		if (config.getPoolConfig() != null) {
+			GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
+			BeanWrapper target = new BeanWrapperImpl(poolConfig);
+			BeanWrapper source = new BeanWrapperImpl(config.getPoolConfig());
+			Util.setCorrespondingProperties(target, source);
+
+			clientConfiguration.poolConfig(poolConfig);
+		}
+	}
+
+	private void configureClient(LettucePoolingClientConfigurationBuilder clientConfiguration, RedisConnectionFactoryConfig config) {
+		if (config.getConnectionProperties() != null) {
+			mapClientConfigurer.configure(clientConfiguration, config.getConnectionProperties());
+		}
+	}
+
+}

spring-cloud-spring-service-connector/src/main/java/org/springframework/cloud/service/keyval/RedisLettuceConnectionFactoryConfigurer.java

@@ -1,28 +0,0 @@
-package org.springframework.cloud.service.keyval;
-
-import org.springframework.cloud.service.*;
-
-import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
-
-/**
- * 
- * @author Mark Paluch
- */
-public class RedisLettuceConnectionFactoryConfigurer implements ServiceConnectorConfigurer<LettuceConnectionFactory, RedisConnectionFactoryConfig> {
-	private MapServiceConnectionConfigurer<LettuceConnectionFactory, MapServiceConnectorConfig> mapServiceConnectionConfigurer =
-			new MapServiceConnectionConfigurer<LettuceConnectionFactory, MapServiceConnectorConfig>();
-
-	@Override
-	public LettuceConnectionFactory configure(LettuceConnectionFactory connectionFactory, RedisConnectionFactoryConfig config) {
-		if (config != null) {
-			configureConnection(connectionFactory, config);
-		}
-		return connectionFactory;
-	}
-
-	private void configureConnection(LettuceConnectionFactory connectionFactory, RedisConnectionFactoryConfig config) {
-		if (config.getConnectionProperties() != null) {
-			mapServiceConnectionConfigurer.configure(connectionFactory, config.getConnectionProperties());
-		}
-	}
-}

spring-cloud-spring-service-connector/src/test/java/org/springframework/cloud/config/RedisConnectionFactoryCloudConfigTestHelper.java

@@ -1,9 +1,11 @@
 package org.springframework.cloud.config;
 
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
-import org.springframework.test.util.ReflectionTestUtils;
-import redis.clients.jedis.JedisPoolConfig;
+import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
 
 import static org.junit.Assert.assertEquals;
 
@@ -14,15 +16,28 @@ import static org.junit.Assert.assertEquals;
  *
  */
 public class RedisConnectionFactoryCloudConfigTestHelper extends CommonPoolCloudConfigTestHelper {
-	
+
 	public static void assertPoolProperties(RedisConnectionFactory connector, int maxActive, int minIdle, long maxWait) {
-		JedisPoolConfig poolConfig = (JedisPoolConfig) ReflectionTestUtils.getField(connector, "poolConfig");
+		GenericObjectPoolConfig poolConfig = null;
+		if (connector instanceof JedisConnectionFactory) {
+			poolConfig = ((JedisConnectionFactory) connector).getPoolConfig();
+		} else if (connector instanceof LettuceConnectionFactory) {
+			LettuceClientConfiguration config = ((LettuceConnectionFactory) connector).getClientConfiguration();
+			if (config instanceof LettucePoolingClientConfiguration) {
+				poolConfig = ((LettucePoolingClientConfiguration) config).getPoolConfig();
+			}
+		}
 		assertCommonsPoolProperties(poolConfig, maxActive, minIdle, maxWait);
 	}
 
 	public static void assertConnectionProperties(RedisConnectionFactory connector, int timeout) {
-		JedisConnectionFactory jedisConnector = (JedisConnectionFactory) connector;
-		assertEquals(timeout, jedisConnector.getTimeout());
+		if (connector instanceof JedisConnectionFactory) {
+			JedisConnectionFactory connectionFactory = (JedisConnectionFactory) connector;
+			assertEquals(timeout, connectionFactory.getTimeout());
+		} else  if (connector instanceof LettuceConnectionFactory) {
+			LettuceConnectionFactory connectionFactory = (LettuceConnectionFactory) connector;
+			assertEquals(timeout, connectionFactory.getTimeout());
+		}
 	}
 
 }

spring-cloud-spring-service-connector/src/test/java/org/springframework/cloud/config/java/RedisConnectionFactoryJavaConfigTest.java

@@ -10,9 +10,6 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 
-import java.util.HashMap;
-import java.util.Map;
-
 /**
  * @author Ramnivas Laddad
  * @author Scott Frederick
@@ -49,27 +46,6 @@ public class RedisConnectionFactoryJavaConfigTest extends AbstractServiceJavaCon
 		RedisConnectionFactory connector = testContext.getBean("pool5_30Wait3000", getConnectorType());
 		RedisConnectionFactoryCloudConfigTestHelper.assertPoolProperties(connector, 30, 5, 3000);
 	}
-
-	@Test
-	public void cloudRedisConnectionFactoryWithTimeout() {
-		ApplicationContext testContext =
-				getTestApplicationContext(RedisConnectionFactoryConfigWithServiceConfig.class,
-						createService("my-service"));
-
-		RedisConnectionFactory connector = testContext.getBean("timeout10", getConnectorType());
-		RedisConnectionFactoryCloudConfigTestHelper.assertConnectionProperties(connector, 10);
-	}
-
-	@Test
-	public void cloudRedisConnectionFactoryWithWithMaxPoolAndTimeout() {
-		ApplicationContext testContext =
-				getTestApplicationContext(RedisConnectionFactoryConfigWithServiceConfig.class,
-						createService("my-service"));
-
-		RedisConnectionFactory connector = testContext.getBean("pool30Wait300_timeout20", getConnectorType());
-		RedisConnectionFactoryCloudConfigTestHelper.assertPoolProperties(connector, 30, 0, 300);
-		RedisConnectionFactoryCloudConfigTestHelper.assertConnectionProperties(connector, 20);
-	}
 }
 
 class RedisConnectionFactoryConfigWithId extends AbstractCloudConfig {
@@ -100,21 +76,4 @@ class RedisConnectionFactoryConfigWithServiceConfig extends AbstractCloudConfig
 		PooledServiceConnectorConfig serviceConfig = new RedisConnectionFactoryConfig(poolConfig);
 		return connectionFactory().redisConnectionFactory("my-service", serviceConfig);
 	}
-
-	@Bean
-	public RedisConnectionFactory timeout10() {
-		Map<String, Object> properties = new HashMap<String, Object>();
-		properties.put("timeout", 10);
-		RedisConnectionFactoryConfig serviceConfig = new RedisConnectionFactoryConfig(properties);
-		return connectionFactory().redisConnectionFactory("my-service", serviceConfig);
-	}
-
-	@Bean
-	public RedisConnectionFactory pool30Wait300_timeout20() {
-		Map<String, Object> properties = new HashMap<String, Object>();
-		properties.put("timeout", 20);
-		PoolConfig poolConfig = new PoolConfig(30, 300);
-		RedisConnectionFactoryConfig serviceConfig = new RedisConnectionFactoryConfig(poolConfig, properties);
-		return connectionFactory().redisConnectionFactory("my-service", serviceConfig);
-	}
 }

spring-cloud-spring-service-connector/src/test/java/org/springframework/cloud/config/xml/RedisConnectionFactoryXmlConfigTest.java

@@ -44,21 +44,4 @@ public class RedisConnectionFactoryXmlConfigTest extends AbstractServiceXmlConfi
 		RedisConnectionFactory connector = testContext.getBean("service-pool5-30-wait3000", getConnectorType());
 		RedisConnectionFactoryCloudConfigTestHelper.assertPoolProperties(connector, 30, 5, 3000);
 	}
-
-	@Test
-	public void cloudRedisConnectionFactoryWithTimeout() {
-		ApplicationContext testContext = getTestApplicationContext("cloud-redis-with-config.xml", createService("my-service"));
-
-		RedisConnectionFactory connector = testContext.getBean("service-timeout10", getConnectorType());
-		RedisConnectionFactoryCloudConfigTestHelper.assertConnectionProperties(connector, 10);
-	}
-
-	@Test
-	public void cloudRedisConnectionFactoryWithMaxPoolAndTimeout() {
-		ApplicationContext testContext = getTestApplicationContext("cloud-redis-with-config.xml", createService("my-service"));
-
-		RedisConnectionFactory connector = testContext.getBean("service-pool30-wait300-timeout20", getConnectorType());
-		RedisConnectionFactoryCloudConfigTestHelper.assertPoolProperties(connector, 30, 0, 300);
-		RedisConnectionFactoryCloudConfigTestHelper.assertConnectionProperties(connector, 20);
-	}
 }

spring-cloud-spring-service-connector/src/test/java/org/springframework/cloud/service/redis/RedisServiceConnectorCreatorTest.java

@@ -11,7 +11,8 @@ import org.mockito.MockitoAnnotations;
 import org.springframework.cloud.service.common.RedisServiceInfo;
 import org.springframework.cloud.service.keyval.RedisConnectionFactoryCreator;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
-import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 
 /**
  * 
@@ -52,9 +53,18 @@ public class RedisServiceConnectorCreatorTest {
 
 	private void assertConnectorProperties(RedisServiceInfo serviceInfo, RedisConnectionFactory connector) {
 		assertNotNull(connector);
-		
-		assertEquals(serviceInfo.getHost(), ReflectionTestUtils.getField(connector, "hostName"));
-		assertEquals(serviceInfo.getPort(), ReflectionTestUtils.getField(connector, "port"));
-		assertEquals(serviceInfo.getPassword(), ReflectionTestUtils.getField(connector, "password"));
+
+		if (connector instanceof JedisConnectionFactory) {
+			JedisConnectionFactory connectionFactory = (JedisConnectionFactory) connector;
+			assertEquals(serviceInfo.getHost(), connectionFactory.getHostName());
+			assertEquals(serviceInfo.getPort(), connectionFactory.getPort());
+			assertEquals(serviceInfo.getPassword(), connectionFactory.getPassword());
+		}
+		if (connector instanceof LettuceConnectionFactory) {
+			LettuceConnectionFactory connectionFactory = (LettuceConnectionFactory) connector;
+			assertEquals(serviceInfo.getHost(), connectionFactory.getHostName());
+			assertEquals(serviceInfo.getPort(), connectionFactory.getPort());
+			assertEquals(serviceInfo.getPassword(), connectionFactory.getPassword());
+		}
 	}
 }

spring-cloud-spring-service-connector/src/test/resources/org/springframework/cloud/config/xml/cloud-redis-with-config.xml

@@ -13,18 +13,4 @@
 	<cloud:redis-connection-factory id="service-pool5-30-wait3000" service-name="my-service">
 		<cloud:pool pool-size="5-30" max-wait-time="3000"/>
 	</cloud:redis-connection-factory>
-
-	<cloud:redis-connection-factory id="service-timeout10" service-name="my-service">
-		<cloud:connection-properties>
-			<entry key="timeout" value="10"/>
-		</cloud:connection-properties>
-	</cloud:redis-connection-factory>
-
-	<cloud:redis-connection-factory id="service-pool30-wait300-timeout20" service-name="my-service">
-		<cloud:pool pool-size="30" max-wait-time="300"/>
-		<cloud:connection-properties>
-			<entry key="timeout" value="20"/>
-		</cloud:connection-properties>
-	</cloud:redis-connection-factory>
-
 </beans>