From f31141de09802030db1192dc6eeb1919cbc72950 Mon Sep 17 00:00:00 2001 From: Hoan Vu Hong Date: Tue, 13 Jul 2021 17:44:11 +0700 Subject: [PATCH 1/2] Mark Redis as down when cluster_state is fail See gh-27300 --- .../boot/actuate/redis/RedisHealth.java | 9 ++- .../actuate/redis/RedisHealthIndicator.java | 2 +- .../redis/RedisReactiveHealthIndicator.java | 6 +- .../redis/RedisHealthIndicatorTests.java | 55 +++++++++++--- .../RedisReactiveHealthIndicatorTests.java | 75 ++++++++++++++----- 5 files changed, 111 insertions(+), 36 deletions(-) diff --git a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java index 028eafe9b23c..21a513b297ac 100644 --- a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java +++ b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java @@ -38,11 +38,16 @@ static Builder up(Health.Builder builder, Properties info) { return builder.up(); } - static Builder up(Health.Builder builder, ClusterInfo clusterInfo) { + static Builder info(Health.Builder builder, ClusterInfo clusterInfo) { builder.withDetail("cluster_size", clusterInfo.getClusterSize()); builder.withDetail("slots_up", clusterInfo.getSlotsOk()); builder.withDetail("slots_fail", clusterInfo.getSlotsFail()); - return builder.up(); + + if ("fail".equalsIgnoreCase(clusterInfo.getState())) { + return builder.down(); + } else { + return builder.up(); + } } } diff --git a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java index 569c850a9234..3d09d6f62d9d 100644 --- a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java +++ b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java @@ -57,7 +57,7 @@ protected void doHealthCheck(Health.Builder builder) throws Exception { private void doHealthCheck(Health.Builder builder, RedisConnection connection) { if (connection instanceof RedisClusterConnection) { - RedisHealth.up(builder, ((RedisClusterConnection) connection).clusterGetClusterInfo()); + RedisHealth.info(builder, ((RedisClusterConnection) connection).clusterGetClusterInfo()); } else { RedisHealth.up(builder, connection.info("server")); diff --git a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java index 757b1fd79193..1ab1802c05f4 100644 --- a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java +++ b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java @@ -65,7 +65,7 @@ private Mono doHealthCheck(Health.Builder builder, ReactiveRedisConnecti private Mono getHealth(Health.Builder builder, ReactiveRedisConnection connection) { if (connection instanceof ReactiveRedisClusterConnection) { return ((ReactiveRedisClusterConnection) connection).clusterGetClusterInfo() - .map((info) -> up(builder, info)); + .map(info -> info(builder, info)); } return connection.serverCommands().info("server").map((info) -> up(builder, info)); } @@ -74,8 +74,8 @@ private Health up(Health.Builder builder, Properties info) { return RedisHealth.up(builder, info).build(); } - private Health up(Health.Builder builder, ClusterInfo clusterInfo) { - return RedisHealth.up(builder, clusterInfo).build(); + private Health info(Health.Builder builder, ClusterInfo clusterInfo) { + return RedisHealth.info(builder, clusterInfo).build(); } } diff --git a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java index 592a0128303a..0a377da273ae 100644 --- a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java +++ b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java @@ -75,20 +75,15 @@ private RedisHealthIndicator createHealthIndicator(RedisConnection redisConnecti } @Test - void redisClusterIsUp() { - Properties clusterProperties = new Properties(); + void redisClusterIsUpWithoutState() { + final Properties clusterProperties = new Properties(); clusterProperties.setProperty("cluster_size", "4"); clusterProperties.setProperty("cluster_slots_ok", "4"); clusterProperties.setProperty("cluster_slots_fail", "0"); - List redisMasterNodes = Arrays.asList(new RedisClusterNode("127.0.0.1", 7001), - new RedisClusterNode("127.0.0.2", 7001)); - RedisClusterConnection redisConnection = mock(RedisClusterConnection.class); - given(redisConnection.clusterGetNodes()).willReturn(redisMasterNodes); - given(redisConnection.clusterGetClusterInfo()).willReturn(new ClusterInfo(clusterProperties)); - RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); - given(redisConnectionFactory.getConnection()).willReturn(redisConnection); - RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); - Health health = healthIndicator.health(); + final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); + + final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); + final Health health = healthIndicator.health(); assertThat(health.getStatus()).isEqualTo(Status.UP); assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L); assertThat(health.getDetails().get("slots_up")).isEqualTo(4L); @@ -96,4 +91,42 @@ void redisClusterIsUp() { verify(redisConnectionFactory, atLeastOnce()).getConnection(); } + @Test + void redisClusterIsUpWithState() { + final Properties clusterProperties = new Properties(); + clusterProperties.setProperty("cluster_state", "ok"); + clusterProperties.setProperty("cluster_size", "4"); + clusterProperties.setProperty("cluster_slots_ok", "4"); + clusterProperties.setProperty("cluster_slots_fail", "0"); + final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); + + final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); + final Health health = healthIndicator.health(); + assertThat(health.getStatus()).isEqualTo(Status.UP); + } + + @Test + void redisClusterIsDown() { + final Properties clusterProperties = new Properties(); + clusterProperties.setProperty("cluster_state", "fail"); + clusterProperties.setProperty("cluster_size", "3"); + clusterProperties.setProperty("cluster_slots_ok", "4"); + clusterProperties.setProperty("cluster_slots_fail", "0"); + final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); + + final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); + final Health health = healthIndicator.health(); + assertThat(health.getStatus()).isEqualTo(Status.DOWN); + } + + private static RedisConnectionFactory mockRedisClusterConnectionFactory(Properties clusterProperties) { + final List redisMasterNodes = Arrays.asList(new RedisClusterNode("127.0.0.1", 7001), + new RedisClusterNode("127.0.0.2", 7001)); + final RedisClusterConnection redisConnection = mock(RedisClusterConnection.class); + given(redisConnection.clusterGetNodes()).willReturn(redisMasterNodes); + given(redisConnection.clusterGetClusterInfo()).willReturn(new ClusterInfo(clusterProperties)); + final RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); + given(redisConnectionFactory.getConnection()).willReturn(redisConnection); + return redisConnectionFactory; + } } diff --git a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java index 8452982dbdfd..d26b5a16b9c9 100644 --- a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java +++ b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java @@ -16,13 +16,14 @@ package org.springframework.boot.actuate.redis; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + import java.util.Properties; -import io.lettuce.core.RedisConnectionException; import org.junit.jupiter.api.Test; -import reactor.core.publisher.Mono; -import reactor.test.StepVerifier; - import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.Status; import org.springframework.data.redis.RedisConnectionFailureException; @@ -32,10 +33,9 @@ import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory; import org.springframework.data.redis.connection.ReactiveServerCommands; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.BDDMockito.given; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; +import io.lettuce.core.RedisConnectionException; +import reactor.core.publisher.Mono; +import reactor.test.StepVerifier; /** * Tests for {@link RedisReactiveHealthIndicator}. @@ -67,25 +67,54 @@ void redisIsUp() { } @Test - void redisClusterIsUp() { - Properties clusterProperties = new Properties(); + void redisClusterIsUpWithoutState() { + final Properties clusterProperties = new Properties(); clusterProperties.setProperty("cluster_size", "4"); clusterProperties.setProperty("cluster_slots_ok", "4"); clusterProperties.setProperty("cluster_slots_fail", "0"); - ReactiveRedisClusterConnection redisConnection = mock(ReactiveRedisClusterConnection.class); - given(redisConnection.closeLater()).willReturn(Mono.empty()); - given(redisConnection.clusterGetClusterInfo()).willReturn(Mono.just(new ClusterInfo(clusterProperties))); - ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); - given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection); - RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); - Mono health = healthIndicator.health(); - StepVerifier.create(health).consumeNextWith((h) -> { + final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); + + final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); + final Mono health = healthIndicator.health(); + StepVerifier.create(health).consumeNextWith(h -> { assertThat(h.getStatus()).isEqualTo(Status.UP); assertThat(h.getDetails().get("cluster_size")).isEqualTo(4L); assertThat(h.getDetails().get("slots_up")).isEqualTo(4L); assertThat(h.getDetails().get("slots_fail")).isEqualTo(0L); }).verifyComplete(); - verify(redisConnection).closeLater(); + verify(redisConnectionFactory.getReactiveConnection()).closeLater(); + } + + @Test + void redisClusterIsUpWithState() { + final Properties clusterProperties = new Properties(); + clusterProperties.setProperty("cluster_state", "ok"); + clusterProperties.setProperty("cluster_size", "4"); + clusterProperties.setProperty("cluster_slots_ok", "4"); + clusterProperties.setProperty("cluster_slots_fail", "0"); + final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); + + final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); + final Mono health = healthIndicator.health(); + StepVerifier.create(health).consumeNextWith(h -> { + assertThat(h.getStatus()).isEqualTo(Status.UP); + }).verifyComplete(); + } + + @Test + void redisClusterIsDown() { + final Properties clusterProperties = new Properties(); + clusterProperties.setProperty("cluster_state", "fail"); + clusterProperties.setProperty("cluster_size", "3"); + clusterProperties.setProperty("cluster_slots_ok", "4"); + clusterProperties.setProperty("cluster_slots_fail", "0"); + final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); + + final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); + final Mono health = healthIndicator.health(); + StepVerifier.create(health).consumeNextWith(h -> { + assertThat(h.getStatus()).isEqualTo(Status.DOWN); + }).verifyComplete(); } @Test @@ -121,4 +150,12 @@ private RedisReactiveHealthIndicator createHealthIndicator(ReactiveRedisConnecti return new RedisReactiveHealthIndicator(redisConnectionFactory); } + private static ReactiveRedisConnectionFactory mockRedisClusterConnectionFactory(Properties clusterProperties) { + final ReactiveRedisClusterConnection redisConnection = mock(ReactiveRedisClusterConnection.class); + given(redisConnection.closeLater()).willReturn(Mono.empty()); + given(redisConnection.clusterGetClusterInfo()).willReturn(Mono.just(new ClusterInfo(clusterProperties))); + final ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); + given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection); + return redisConnectionFactory; + } } From 49baacbc1cb02a59efce1fe1698166de92d41d67 Mon Sep 17 00:00:00 2001 From: Andy Wilkinson Date: Tue, 13 Jul 2021 14:36:39 +0100 Subject: [PATCH 2/2] Polish "Mark Redis as down when cluster_state is fail" See gh-27300 --- .../boot/actuate/redis/RedisHealth.java | 7 +- .../actuate/redis/RedisHealthIndicator.java | 4 +- .../redis/RedisReactiveHealthIndicator.java | 8 +- .../redis/RedisHealthIndicatorTests.java | 82 +++++++++--------- .../RedisReactiveHealthIndicatorTests.java | 86 +++++++++---------- 5 files changed, 93 insertions(+), 94 deletions(-) diff --git a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java index 21a513b297ac..943c2a19aa79 100644 --- a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java +++ b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealth.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2020 the original author or authors. + * Copyright 2012-2021 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. @@ -38,14 +38,15 @@ static Builder up(Health.Builder builder, Properties info) { return builder.up(); } - static Builder info(Health.Builder builder, ClusterInfo clusterInfo) { + static Builder fromClusterInfo(Health.Builder builder, ClusterInfo clusterInfo) { builder.withDetail("cluster_size", clusterInfo.getClusterSize()); builder.withDetail("slots_up", clusterInfo.getSlotsOk()); builder.withDetail("slots_fail", clusterInfo.getSlotsFail()); if ("fail".equalsIgnoreCase(clusterInfo.getState())) { return builder.down(); - } else { + } + else { return builder.up(); } } diff --git a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java index 3d09d6f62d9d..63486870c234 100644 --- a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java +++ b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisHealthIndicator.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2020 the original author or authors. + * Copyright 2012-2021 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. @@ -57,7 +57,7 @@ protected void doHealthCheck(Health.Builder builder) throws Exception { private void doHealthCheck(Health.Builder builder, RedisConnection connection) { if (connection instanceof RedisClusterConnection) { - RedisHealth.info(builder, ((RedisClusterConnection) connection).clusterGetClusterInfo()); + RedisHealth.fromClusterInfo(builder, ((RedisClusterConnection) connection).clusterGetClusterInfo()); } else { RedisHealth.up(builder, connection.info("server")); diff --git a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java index 1ab1802c05f4..e91553170828 100644 --- a/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java +++ b/spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2020 the original author or authors. + * Copyright 2012-2021 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. @@ -65,7 +65,7 @@ private Mono doHealthCheck(Health.Builder builder, ReactiveRedisConnecti private Mono getHealth(Health.Builder builder, ReactiveRedisConnection connection) { if (connection instanceof ReactiveRedisClusterConnection) { return ((ReactiveRedisClusterConnection) connection).clusterGetClusterInfo() - .map(info -> info(builder, info)); + .map((info) -> fromClusterInfo(builder, info)); } return connection.serverCommands().info("server").map((info) -> up(builder, info)); } @@ -74,8 +74,8 @@ private Health up(Health.Builder builder, Properties info) { return RedisHealth.up(builder, info).build(); } - private Health info(Health.Builder builder, ClusterInfo clusterInfo) { - return RedisHealth.info(builder, clusterInfo).build(); + private Health fromClusterInfo(Health.Builder builder, ClusterInfo clusterInfo) { + return RedisHealth.fromClusterInfo(builder, clusterInfo).build(); } } diff --git a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java index 0a377da273ae..0dfd4f2672d8 100644 --- a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java +++ b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisHealthIndicatorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2020 the original author or authors. + * Copyright 2012-2021 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. @@ -68,22 +68,11 @@ void redisIsDown() { assertThat((String) health.getDetails().get("error")).contains("Connection failed"); } - private RedisHealthIndicator createHealthIndicator(RedisConnection redisConnection) { - RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); - given(redisConnectionFactory.getConnection()).willReturn(redisConnection); - return new RedisHealthIndicator(redisConnectionFactory); - } - @Test - void redisClusterIsUpWithoutState() { - final Properties clusterProperties = new Properties(); - clusterProperties.setProperty("cluster_size", "4"); - clusterProperties.setProperty("cluster_slots_ok", "4"); - clusterProperties.setProperty("cluster_slots_fail", "0"); - final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); - - final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); - final Health health = healthIndicator.health(); + void healthWhenClusterStateIsAbsentShouldBeUp() { + RedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory(null); + RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); + Health health = healthIndicator.health(); assertThat(health.getStatus()).isEqualTo(Status.UP); assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L); assertThat(health.getDetails().get("slots_up")).isEqualTo(4L); @@ -92,41 +81,52 @@ void redisClusterIsUpWithoutState() { } @Test - void redisClusterIsUpWithState() { - final Properties clusterProperties = new Properties(); - clusterProperties.setProperty("cluster_state", "ok"); - clusterProperties.setProperty("cluster_size", "4"); - clusterProperties.setProperty("cluster_slots_ok", "4"); - clusterProperties.setProperty("cluster_slots_fail", "0"); - final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); - - final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); - final Health health = healthIndicator.health(); + void healthWhenClusterStateIsOkShouldBeUp() { + RedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("ok"); + RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); + Health health = healthIndicator.health(); assertThat(health.getStatus()).isEqualTo(Status.UP); + assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L); + assertThat(health.getDetails().get("slots_up")).isEqualTo(4L); + assertThat(health.getDetails().get("slots_fail")).isEqualTo(0L); + verify(redisConnectionFactory, atLeastOnce()).getConnection(); } @Test - void redisClusterIsDown() { - final Properties clusterProperties = new Properties(); - clusterProperties.setProperty("cluster_state", "fail"); - clusterProperties.setProperty("cluster_size", "3"); - clusterProperties.setProperty("cluster_slots_ok", "4"); - clusterProperties.setProperty("cluster_slots_fail", "0"); - final RedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); - - final RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); - final Health health = healthIndicator.health(); + void healthWhenClusterStateIsFailShouldBeDown() { + RedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("fail"); + RedisHealthIndicator healthIndicator = new RedisHealthIndicator(redisConnectionFactory); + Health health = healthIndicator.health(); assertThat(health.getStatus()).isEqualTo(Status.DOWN); + assertThat(health.getDetails().get("cluster_size")).isEqualTo(4L); + assertThat(health.getDetails().get("slots_up")).isEqualTo(3L); + assertThat(health.getDetails().get("slots_fail")).isEqualTo(1L); + verify(redisConnectionFactory, atLeastOnce()).getConnection(); + } + + private RedisHealthIndicator createHealthIndicator(RedisConnection redisConnection) { + RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); + given(redisConnectionFactory.getConnection()).willReturn(redisConnection); + return new RedisHealthIndicator(redisConnectionFactory); } - private static RedisConnectionFactory mockRedisClusterConnectionFactory(Properties clusterProperties) { - final List redisMasterNodes = Arrays.asList(new RedisClusterNode("127.0.0.1", 7001), - new RedisClusterNode("127.0.0.2", 7001)); - final RedisClusterConnection redisConnection = mock(RedisClusterConnection.class); + private RedisConnectionFactory createClusterConnectionFactory(String state) { + Properties clusterProperties = new Properties(); + if (state != null) { + clusterProperties.setProperty("cluster_state", state); + } + clusterProperties.setProperty("cluster_size", "4"); + boolean failure = "fail".equals(state); + clusterProperties.setProperty("cluster_slots_ok", failure ? "3" : "4"); + clusterProperties.setProperty("cluster_slots_fail", failure ? "1" : "0"); + List redisMasterNodes = Arrays.asList(new RedisClusterNode("127.0.0.1", 7001), + new RedisClusterNode("127.0.0.2", 7001)); + RedisClusterConnection redisConnection = mock(RedisClusterConnection.class); given(redisConnection.clusterGetNodes()).willReturn(redisMasterNodes); given(redisConnection.clusterGetClusterInfo()).willReturn(new ClusterInfo(clusterProperties)); - final RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); + RedisConnectionFactory redisConnectionFactory = mock(RedisConnectionFactory.class); given(redisConnectionFactory.getConnection()).willReturn(redisConnection); return redisConnectionFactory; } + } diff --git a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java index d26b5a16b9c9..431cdf165e1c 100644 --- a/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java +++ b/spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicatorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2020 the original author or authors. + * Copyright 2012-2021 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. @@ -16,14 +16,13 @@ package org.springframework.boot.actuate.redis; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.BDDMockito.given; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; - import java.util.Properties; +import io.lettuce.core.RedisConnectionException; import org.junit.jupiter.api.Test; +import reactor.core.publisher.Mono; +import reactor.test.StepVerifier; + import org.springframework.boot.actuate.health.Health; import org.springframework.boot.actuate.health.Status; import org.springframework.data.redis.RedisConnectionFailureException; @@ -33,9 +32,10 @@ import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory; import org.springframework.data.redis.connection.ReactiveServerCommands; -import io.lettuce.core.RedisConnectionException; -import reactor.core.publisher.Mono; -import reactor.test.StepVerifier; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; /** * Tests for {@link RedisReactiveHealthIndicator}. @@ -67,16 +67,11 @@ void redisIsUp() { } @Test - void redisClusterIsUpWithoutState() { - final Properties clusterProperties = new Properties(); - clusterProperties.setProperty("cluster_size", "4"); - clusterProperties.setProperty("cluster_slots_ok", "4"); - clusterProperties.setProperty("cluster_slots_fail", "0"); - final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); - - final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); - final Mono health = healthIndicator.health(); - StepVerifier.create(health).consumeNextWith(h -> { + void healthWhenClusterStateIsAbsentShouldBeUp() { + ReactiveRedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory(null); + RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); + Mono health = healthIndicator.health(); + StepVerifier.create(health).consumeNextWith((h) -> { assertThat(h.getStatus()).isEqualTo(Status.UP); assertThat(h.getDetails().get("cluster_size")).isEqualTo(4L); assertThat(h.getDetails().get("slots_up")).isEqualTo(4L); @@ -86,34 +81,29 @@ void redisClusterIsUpWithoutState() { } @Test - void redisClusterIsUpWithState() { - final Properties clusterProperties = new Properties(); - clusterProperties.setProperty("cluster_state", "ok"); - clusterProperties.setProperty("cluster_size", "4"); - clusterProperties.setProperty("cluster_slots_ok", "4"); - clusterProperties.setProperty("cluster_slots_fail", "0"); - final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); - - final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); - final Mono health = healthIndicator.health(); - StepVerifier.create(health).consumeNextWith(h -> { + void healthWhenClusterStateIsOkShouldBeUp() { + ReactiveRedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("ok"); + RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); + Mono health = healthIndicator.health(); + StepVerifier.create(health).consumeNextWith((h) -> { assertThat(h.getStatus()).isEqualTo(Status.UP); + assertThat(h.getDetails().get("cluster_size")).isEqualTo(4L); + assertThat(h.getDetails().get("slots_up")).isEqualTo(4L); + assertThat(h.getDetails().get("slots_fail")).isEqualTo(0L); }).verifyComplete(); } @Test - void redisClusterIsDown() { - final Properties clusterProperties = new Properties(); + void healthWhenClusterStateIsFailShouldBeDown() { + Properties clusterProperties = new Properties(); clusterProperties.setProperty("cluster_state", "fail"); - clusterProperties.setProperty("cluster_size", "3"); - clusterProperties.setProperty("cluster_slots_ok", "4"); - clusterProperties.setProperty("cluster_slots_fail", "0"); - final ReactiveRedisConnectionFactory redisConnectionFactory = mockRedisClusterConnectionFactory(clusterProperties); - - final RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); - final Mono health = healthIndicator.health(); - StepVerifier.create(health).consumeNextWith(h -> { + ReactiveRedisConnectionFactory redisConnectionFactory = createClusterConnectionFactory("fail"); + RedisReactiveHealthIndicator healthIndicator = new RedisReactiveHealthIndicator(redisConnectionFactory); + Mono health = healthIndicator.health(); + StepVerifier.create(health).consumeNextWith((h) -> { assertThat(h.getStatus()).isEqualTo(Status.DOWN); + assertThat(h.getDetails().get("slots_up")).isEqualTo(3L); + assertThat(h.getDetails().get("slots_fail")).isEqualTo(1L); }).verifyComplete(); } @@ -143,19 +133,27 @@ void redisConnectionIsDown() { private RedisReactiveHealthIndicator createHealthIndicator(ReactiveRedisConnection redisConnection, ReactiveServerCommands serverCommands) { - ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection); given(redisConnection.serverCommands()).willReturn(serverCommands); return new RedisReactiveHealthIndicator(redisConnectionFactory); } - private static ReactiveRedisConnectionFactory mockRedisClusterConnectionFactory(Properties clusterProperties) { - final ReactiveRedisClusterConnection redisConnection = mock(ReactiveRedisClusterConnection.class); + private ReactiveRedisConnectionFactory createClusterConnectionFactory(String state) { + Properties clusterProperties = new Properties(); + if (state != null) { + clusterProperties.setProperty("cluster_state", state); + } + clusterProperties.setProperty("cluster_size", "4"); + boolean failure = "fail".equals(state); + clusterProperties.setProperty("cluster_slots_ok", failure ? "3" : "4"); + clusterProperties.setProperty("cluster_slots_fail", failure ? "1" : "0"); + ReactiveRedisClusterConnection redisConnection = mock(ReactiveRedisClusterConnection.class); given(redisConnection.closeLater()).willReturn(Mono.empty()); given(redisConnection.clusterGetClusterInfo()).willReturn(Mono.just(new ClusterInfo(clusterProperties))); - final ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); + ReactiveRedisConnectionFactory redisConnectionFactory = mock(ReactiveRedisConnectionFactory.class); given(redisConnectionFactory.getReactiveConnection()).willReturn(redisConnection); return redisConnectionFactory; } + }