org.springframework.cloud.service.common.RedisServiceInfo Java Examples

public RedisServiceInfo createServiceInfo(Map<String,Object> serviceData) {
	String id = getId(serviceData);

	Map<String, Object> credentials = getCredentials(serviceData);
	String uri = getUriFromCredentials(credentials);

	if (uri == null) {
		String host = getStringFromCredentials(credentials, "hostname", "host");
		int port = getIntFromCredentials(credentials, "port");
		String password = (String) credentials.get("password");

		return new RedisServiceInfo(id, host, port, password);
	} else {
		return new RedisServiceInfo(id, uri);
	}
}
 

@Test
public void mysqlLatticeWorks() {
	LatticeConnector connector = createConnector();

	RedisServiceInfo serviceInfo = findServiceInfo(connector, RedisServiceInfo.class, "redis-1");
	assertThat(serviceInfo.getUri(), equalTo("redis://192.168.11.11:61001"));
}
 

@Test
public void redisServiceCreation() {
	for (String redisEnv : new String[]{"REDISTOGO_URL", "REDISCLOUD_URL", "OPENREDIS_URL", "REDISGREEN_URL", "REDIS_URL"}) {
		Map<String, String> env = new HashMap<String, String>();
		String redisUrl = getRedisServiceUrl();
		env.put(redisEnv, redisUrl);
		when(mockEnvironment.getEnv()).thenReturn(env);

		List<ServiceInfo> serviceInfos = testCloudConnector.getServiceInfos();
		ServiceInfo serviceInfo = getServiceInfo(serviceInfos, redisEnv.substring(0, redisEnv.length() - 4));
		assertNotNull(serviceInfo);
		assertTrue(serviceInfo instanceof RedisServiceInfo);
		assertRedisServiceInfo((RedisServiceInfo) serviceInfo);
	}
}
 

@Test
public void serviceCreation() {
	List<ServiceInfo> services = connector.getServiceInfos();
	ServiceInfo service = getServiceInfo(services, "blue");
	assertNotNull(service);
	assertTrue(service instanceof RedisServiceInfo);
	assertUriParameters((RedisServiceInfo) service);
}
 

@Test
public void redisServiceCreationNoLabelNoTags() {
	when(mockEnvironment.getEnvValue("VCAP_SERVICES"))
			.thenReturn(getServicesPayload(
					getRedisServicePayloadNoLabelNoTags("redis-1", hostname, port, password, "redis-db"),
					getRedisServicePayloadNoLabelNoTags("redis-2", hostname, port, password, "redis-db")));

	List<ServiceInfo> serviceInfos = testCloudConnector.getServiceInfos();
	assertServiceFoundOfType(serviceInfos, "redis-1", RedisServiceInfo.class);
	assertServiceFoundOfType(serviceInfos, "redis-2", RedisServiceInfo.class);
}
 

@Test
public void redisServiceCreation() {
	when(mockEnvironment.getEnvValue("VCAP_SERVICES"))
		.thenReturn(getServicesPayload(
				getRedisServicePayload("redis-1", hostname, port, password, "redis-db"),
				getRedisServicePayload("redis-2", hostname, port, password, "redis-db")));

	List<ServiceInfo> serviceInfos = testCloudConnector.getServiceInfos();
	assertServiceFoundOfType(serviceInfos, "redis-1", RedisServiceInfo.class);
	assertServiceFoundOfType(serviceInfos, "redis-2", RedisServiceInfo.class);
}
 

public RedisServiceInfo createServiceInfo(String scheme) {
	when(mockRedisServiceInfo.getScheme()).thenReturn(scheme);
	when(mockRedisServiceInfo.getHost()).thenReturn(TEST_HOST);
	when(mockRedisServiceInfo.getPort()).thenReturn(TEST_PORT);
	when(mockRedisServiceInfo.getPassword()).thenReturn(TEST_PASSWORD);
	
	return mockRedisServiceInfo;
}
 

@Test
public void cloudRedisCreationSecureConnection() {
	RedisServiceInfo serviceInfo = createServiceInfo(RedisServiceInfo.REDISS_SCHEME);

	RedisConnectionFactory dataSource = testCreator.create(serviceInfo, null);

	assertConnectorProperties(serviceInfo, dataSource, true);
}
 

@Test
public void cloudRedisCreationNoConfig() {
	RedisServiceInfo serviceInfo = createServiceInfo(RedisServiceInfo.REDIS_SCHEME);

	RedisConnectionFactory dataSource = testCreator.create(serviceInfo, null);

	assertConnectorProperties(serviceInfo, dataSource, false);
}
 

public RedisServiceInfo createServiceInfo() {
    when(mockRedisServiceInfo.getHost()).thenReturn(TEST_HOST);
    when(mockRedisServiceInfo.getPort()).thenReturn(TEST_PORT);
    when(mockRedisServiceInfo.getPassword()).thenReturn(TEST_PASSWORD);

    return mockRedisServiceInfo;
}
 

@Test
public void cloudRedisCreationNoConfig() throws Exception {
    RedisServiceInfo serviceInfo = createServiceInfo();

    RedisConnectionFactory dataSource = testCreator.create(serviceInfo, null);

    assertConnectorProperties(serviceInfo, dataSource);
}
 

@Test
public void servicePropsRedis() {
	String serviceId = "my-redis";
	RedisServiceInfo redisServiceInfo = createRedisService(serviceId);
	CloudConnector stubCloudConnector = getTestCloudConnector(redisServiceInfo);
	Cloud testCloud = new Cloud(stubCloudConnector, serviceCreators);

	Properties cloudProperties = testCloud.getCloudProperties();
	
	assertBasicProps("cloud.services.my-redis", redisServiceInfo, cloudProperties);
	assertBasicProps("cloud.services.redis", redisServiceInfo, cloudProperties);
}
 

@Override
public RedisServiceInfo createServiceInfo(Process process) {
	ActualLRPResponse actual = process.getFirstActual();
	String address = actual.getAddress();
	int port = actual.getPorts()[0].getHostPort();
	String password = null;
	return new RedisServiceInfo(actual.getInstanceGuid(), address, port, password);
}
 

public RedisServiceInfo getTestServiceInfo(String id) {
	return new RedisServiceInfo(id, "host", 0, "password");
}
 

public RedisServiceInfo getTestServiceInfo(String id) {
    return new RedisServiceInfo(id, "host", 0, "password");
}
 

public RedisServiceInfoCreator() {
	// the literal in the tag is CloudFoundry-specific
	super(new Tags("redis"), RedisServiceInfo.REDIS_SCHEME, RedisServiceInfo.REDISS_SCHEME);
}
 

protected RedisServiceInfo createRedisService(String id) {
	return new RedisServiceInfo(id, "host", 1234, "password");
}
 

public RedisServiceInfoCreator() {
	super(RedisServiceInfo.REDIS_SCHEME);
}
 

@Override
public RedisServiceInfo createServiceInfo(String id, String uri) {
	return new RedisServiceInfo(id, uri);
}
 

private boolean connectionIsSecure(RedisServiceInfo serviceInfo) {
	return RedisServiceInfo.REDISS_SCHEME.equalsIgnoreCase(serviceInfo.getScheme());
}
 

public RedisServiceInfoCreator() {
	super(RedisServiceInfo.REDIS_SCHEME);
}
 

@Override
public RedisServiceInfo createServiceInfo(String id, String uri) {
	return new RedisServiceInfo(HerokuUtil.computeServiceName(id), uri);
}
 

protected void assertRedisServiceInfo(RedisServiceInfo serviceInfo) {
	assertEquals(hostname, serviceInfo.getHost());
	assertEquals(port, serviceInfo.getPort());
	assertEquals(username, serviceInfo.getUserName());
	assertEquals(password, serviceInfo.getPassword());
}