TOC

Servidor Redis incorporado com teste de inicialização por mola

Servidor Redis incorporado com teste de inicialização por mola

1. Visão geral

O Spring Data Redis fornece uma maneira fácil de integração com instâncias deRedis.

No entanto, em alguns casos,it’s more convenient to use an embedded server than to create an environment with a real server.

Portanto, aprenderemos como configurar e usar o servidor Redis incorporado.

2. Dependências

Vamos começar adicionando as dependências necessárias: 


  org.springframework.boot
  spring-boot-starter-data-redis



  it.ozimov
  embedded-redis
  0.7.2
  test



  org.springframework.boot
  spring-boot-starter-test
  test

A dependênciaspring-boot-starter-test contém tudo o que precisamos para executar os testes de integração.

Além disso, oembedded-redis contém o servidor integrado que usaremos.

3. Configuração

Após adicionar as dependências, devemos definir as configurações de conexão entre o servidor Redis e nosso aplicativo.

Vamos começar criando uma classe que conterá nossas propriedades: 

@Configuration
public class RedisProperties {
    private int redisPort;
    private String redisHost;

    public RedisProperties(
      @Value("${spring.redis.port}") int redisPort,
      @Value("${spring.redis.host}") String redisHost) {
        this.redisPort = redisPort;
        this.redisHost = redisHost;
    }

    // getters
}

Em seguida, devemos criar uma classe de configuração que defina a conexão e use nossas propriedades: 

@Configuration
@EnableRedisRepositories
public class RedisConfiguration {

    @Bean
    public LettuceConnectionFactory redisConnectionFactory(
      RedisProperties redisProperties) {
        return new LettuceConnectionFactory(
          redisProperties.getRedisHost(),
          redisProperties.getRedisPort());
    }

    @Bean
    public RedisTemplate redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        return template;
    }
}

A configuração é bastante simples. Além disso, ele nos permite executar o servidor incorporado em uma porta diferente.

Confira nosso artigoIntroduction to Spring Data Redis para saber mais sobre o Redis com Spring Boot.

4. Servidor Redis incorporado

Agora, vamos configurar o servidor incorporado e usá-lo em um de nossos testes.

Em primeiro lugar, vamos criar um arquivoapplication.properties no diretório de recursos de teste (src/test/resources): 

spring.redis.host=localhost
spring.redis.port=6370

Depois disso, vamos criar uma classe anotada@TestConfiguration: 

@TestConfiguration
public class TestRedisConfiguration {

    private RedisServer redisServer;

    public TestRedisConfiguration(RedisProperties redisProperties) {
        this.redisServer = new RedisServer(redisProperties.getRedisPort());
    }

    @PostConstruct
    public void postConstruct() {
        redisServer.start();
    }

    @PreDestroy
    public void preDestroy() {
        redisServer.stop();
    }
}

The server will start once the context is up. It’ll start on our machine on the port that we’ve defined in our properties. Por exemplo, agora podemos executar o teste sem parar o servidor Redis real.

Idealmente, gostaríamos de iniciá-lo na porta disponível aleatória, mas o Redis incorporado ainda não tem esse recurso. O que poderíamos fazer agora é obter a porta aleatória por meio da API ServerSocket.

Além disso, o servidor será interrompido assim que o contexto for destruído.

O servidor também pode ser fornecido com nosso próprio executável: 

this.redisServer = new RedisServer("/path/redis", redisProperties.getRedisPort());

Além disso, o executável pode ser definido por sistema operacional: 

RedisExecProvider customProvider = RedisExecProvider.defaultProvider()
  .override(OS.UNIX, "/path/unix/redis")
  .override(OS.Windows, Architecture.x86_64, "/path/windows/redis")
  .override(OS.MAC_OS_X, Architecture.x86_64, "/path/macosx/redis")

this.redisServer = new RedisServer(customProvider, redisProperties.getRedisPort());

Finalmente, vamos criar um teste que usará nossa classeTestRedisConfiguration: 

@RunWith(SpringRunner.class)
@SpringBootTest(classes = TestRedisConfiguration.class)
public class UserRepositoryIntegrationTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    public void shouldSaveUser_toRedis() {
        UUID id = UUID.randomUUID();
        User user = new User(id, "name");

        User saved = userRepository.save(user);

        assertNotNull(saved);
    }
}

O usuário foi salvo no nosso servidor Redis incorporado.

Além disso, tivemos que adicionar manualmenteTestRedisConfiguration toSpringBootTest. Como dissemos anteriormente, o servidor iniciou antes do teste e parou depois.

5. Conclusão

O Embedded Redis Server é a ferramenta perfeita para substituir o servidor real no ambiente de teste. Vimos como configurá-lo e como usá-lo em nosso teste.

Como sempre, o código para exemplos está disponívelover on GitHub.

Related