@Test
void customRedisSerializerConfig() {
	registerAndRefresh(RedisConfig.class, CustomRedisSerializerConfig.class);

	ReactiveRedisSessionRepository repository = this.context.getBean(ReactiveRedisSessionRepository.class);
	@SuppressWarnings("unchecked")
	RedisSerializer<Object> redisSerializer = this.context.getBean("springSessionDefaultRedisSerializer",
			RedisSerializer.class);
	assertThat(repository).isNotNull();
	assertThat(redisSerializer).isNotNull();
	ReactiveRedisOperations redisOperations = (ReactiveRedisOperations) ReflectionTestUtils.getField(repository,
			"sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	RedisSerializationContext serializationContext = redisOperations.getSerializationContext();
	assertThat(ReflectionTestUtils.getField(serializationContext.getValueSerializationPair().getReader(),
			"serializer")).isEqualTo(redisSerializer);
	assertThat(ReflectionTestUtils.getField(serializationContext.getValueSerializationPair().getWriter(),
			"serializer")).isEqualTo(redisSerializer);
	assertThat(ReflectionTestUtils.getField(serializationContext.getHashValueSerializationPair().getReader(),
			"serializer")).isEqualTo(redisSerializer);
	assertThat(ReflectionTestUtils.getField(serializationContext.getHashValueSerializationPair().getWriter(),
			"serializer")).isEqualTo(redisSerializer);
}
 

@Test
void springSessionRedisOperationsResolvingConfiguration() {
	registerAndRefresh(RedisConfig.class, SpringSessionRedisOperationsResolvingConfig.class);

	ReactiveRedisSessionRepository repository = this.context.getBean(ReactiveRedisSessionRepository.class);
	assertThat(repository).isNotNull();
	ReactiveRedisOperations<String, Object> springSessionRedisOperations = this.context
			.getBean(SpringSessionRedisOperationsResolvingConfig.class).getSpringSessionRedisOperations();
	assertThat(springSessionRedisOperations).isNotNull();
	assertThat((ReactiveRedisOperations) ReflectionTestUtils.getField(repository, "sessionRedisOperations"))
			.isEqualTo(springSessionRedisOperations);
}
 

@Test
void qualifiedConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class, QualifiedConnectionFactoryRedisConfig.class);

	ReactiveRedisSessionRepository repository = this.context.getBean(ReactiveRedisSessionRepository.class);
	ReactiveRedisConnectionFactory redisConnectionFactory = this.context.getBean("qualifiedRedisConnectionFactory",
			ReactiveRedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	ReactiveRedisOperations redisOperations = (ReactiveRedisOperations) ReflectionTestUtils.getField(repository,
			"sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

@Test
void primaryConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class, PrimaryConnectionFactoryRedisConfig.class);

	ReactiveRedisSessionRepository repository = this.context.getBean(ReactiveRedisSessionRepository.class);
	ReactiveRedisConnectionFactory redisConnectionFactory = this.context.getBean("primaryRedisConnectionFactory",
			ReactiveRedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	ReactiveRedisOperations redisOperations = (ReactiveRedisOperations) ReflectionTestUtils.getField(repository,
			"sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

@Test
void qualifiedAndPrimaryConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class, QualifiedAndPrimaryConnectionFactoryRedisConfig.class);

	ReactiveRedisSessionRepository repository = this.context.getBean(ReactiveRedisSessionRepository.class);
	ReactiveRedisConnectionFactory redisConnectionFactory = this.context.getBean("qualifiedRedisConnectionFactory",
			ReactiveRedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	ReactiveRedisOperations redisOperations = (ReactiveRedisOperations) ReflectionTestUtils.getField(repository,
			"sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

@Test
void namedConnectionFactoryRedisConfig() {
	registerAndRefresh(RedisConfig.class, NamedConnectionFactoryRedisConfig.class);

	ReactiveRedisSessionRepository repository = this.context.getBean(ReactiveRedisSessionRepository.class);
	ReactiveRedisConnectionFactory redisConnectionFactory = this.context.getBean("redisConnectionFactory",
			ReactiveRedisConnectionFactory.class);
	assertThat(repository).isNotNull();
	assertThat(redisConnectionFactory).isNotNull();
	ReactiveRedisOperations redisOperations = (ReactiveRedisOperations) ReflectionTestUtils.getField(repository,
			"sessionRedisOperations");
	assertThat(redisOperations).isNotNull();
	assertThat(ReflectionTestUtils.getField(redisOperations, "connectionFactory"))
			.isEqualTo(redisConnectionFactory);
}
 

@Bean
@ConfigurationProperties(prefix = "hsweb.user-token")
public UserTokenManager userTokenManager(ReactiveRedisOperations<Object,Object> template) {
    return new RedisUserTokenManager(template);
}
 

public PostRepository(ReactiveRedisOperations<String, Post> template) {
    this.template = template;
}
 

ReactiveRedisOperations<String, Object> getSpringSessionRedisOperations() {
	return this.springSessionRedisOperations;
}
 

/**
 * Create a new {@link ReactiveRedisSessionRepository} instance.
 * @param sessionRedisOperations the {@link ReactiveRedisOperations} to use for
 * managing sessions
 */
public ReactiveRedisSessionRepository(ReactiveRedisOperations<String, Object> sessionRedisOperations) {
	Assert.notNull(sessionRedisOperations, "sessionRedisOperations cannot be null");
	this.sessionRedisOperations = sessionRedisOperations;
}
 

/**
 * Returns the {@link ReactiveRedisOperations} used for sessions.
 * @return the {@link ReactiveRedisOperations} used for sessions
 */
public ReactiveRedisOperations<String, Object> getSessionRedisOperations() {
	return this.sessionRedisOperations;
}
 

/**
 * Create a new {@link ReactiveRedisOperationsSessionRepository} instance.
 * @param sessionRedisOperations the {@link ReactiveRedisOperations} to use for
 * managing sessions
 * @see ReactiveRedisSessionRepository#ReactiveRedisSessionRepository(ReactiveRedisOperations)
 */
public ReactiveRedisOperationsSessionRepository(ReactiveRedisOperations<String, Object> sessionRedisOperations) {
	super(sessionRedisOperations);
}