diff options
Diffstat (limited to 'server/sonar-server')
6 files changed, 562 insertions, 41 deletions
diff --git a/server/sonar-server/src/main/java/org/sonar/server/health/AppNodeClusterCheck.java b/server/sonar-server/src/main/java/org/sonar/server/health/AppNodeClusterCheck.java new file mode 100644 index 00000000000..f91b51ab5f4 --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/health/AppNodeClusterCheck.java @@ -0,0 +1,112 @@ +/* + * SonarQube + * Copyright (C) 2009-2017 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.health; + +import java.util.Arrays; +import java.util.Set; +import org.sonar.cluster.health.NodeDetails; +import org.sonar.cluster.health.NodeHealth; + +import static org.sonar.cluster.health.NodeHealth.Status.GREEN; +import static org.sonar.cluster.health.NodeHealth.Status.RED; +import static org.sonar.cluster.health.NodeHealth.Status.YELLOW; +import static org.sonar.core.util.stream.MoreCollectors.toSet; +import static org.sonar.server.health.Health.newHealthCheckBuilder; + +public class AppNodeClusterCheck implements ClusterHealthCheck { + + @Override + public Health check(Set<NodeHealth> nodeHealths) { + Set<NodeHealth> appNodes = nodeHealths.stream() + .filter(s -> s.getDetails().getType() == NodeDetails.Type.APPLICATION) + .collect(toSet()); + + return Arrays.stream(AppNodeClusterHealthChecks.values()) + .map(s -> s.check(appNodes)) + .reduce(Health.GREEN, HealthReducer.INSTANCE); + } + + private enum AppNodeClusterHealthChecks implements ClusterHealthCheck { + NO_APPLICATION_NODE() { + @Override + public Health check(Set<NodeHealth> appNodes) { + int appNodeCount = appNodes.size(); + if (appNodeCount == 0) { + return newHealthCheckBuilder() + .setStatus(Health.Status.RED) + .addCause("No application node") + .build(); + } + return Health.GREEN; + } + }, + MIN_APPLICATION_NODE_COUNT() { + @Override + public Health check(Set<NodeHealth> appNodes) { + int appNodeCount = appNodes.size(); + if (appNodeCount == 1) { + return newHealthCheckBuilder() + .setStatus(Health.Status.YELLOW) + .addCause("There should be at least two application nodes") + .build(); + } + return Health.GREEN; + } + }, + REPORT_RED_OR_YELLOW_NODES() { + @Override + public Health check(Set<NodeHealth> appNodes) { + int appNodeCount = appNodes.size(); + if (appNodeCount == 0) { + // skipping this check + return Health.GREEN; + } + + long redNodesCount = appNodes.stream().filter(s -> s.getStatus() == RED).count(); + long yellowNodesCount = appNodes.stream().filter(s -> s.getStatus() == YELLOW).count(); + if (redNodesCount == 0 && yellowNodesCount == 0) { + return Health.GREEN; + } + + Health.Builder builder = newHealthCheckBuilder(); + if (redNodesCount == appNodeCount) { + return builder + .setStatus(Health.Status.RED) + .addCause("Status of all application nodes is RED") + .build(); + } else if (redNodesCount > 0) { + builder.addCause("At least one application node is RED"); + } + if (yellowNodesCount == appNodeCount) { + return builder + .setStatus(Health.Status.YELLOW) + .addCause("Status of all application nodes is YELLOW") + .build(); + } else if (yellowNodesCount > 0) { + builder.addCause("At least one application node is YELLOW"); + } + long greenNodesCount = appNodes.stream().filter(s -> s.getStatus() == GREEN).count(); + builder.setStatus(greenNodesCount > 0 || yellowNodesCount > 0 ? Health.Status.YELLOW : Health.Status.RED); + + return builder.build(); + } + } + } +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/health/HealthCheckerImpl.java b/server/sonar-server/src/main/java/org/sonar/server/health/HealthCheckerImpl.java index fbaabfe4f18..6fea8ab8e45 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/health/HealthCheckerImpl.java +++ b/server/sonar-server/src/main/java/org/sonar/server/health/HealthCheckerImpl.java @@ -21,8 +21,6 @@ package org.sonar.server.health; import java.util.List; import java.util.Set; -import java.util.function.BinaryOperator; -import java.util.stream.Stream; import javax.annotation.CheckForNull; import javax.annotation.Nullable; import org.sonar.cluster.health.NodeHealth; @@ -31,7 +29,6 @@ import org.sonar.server.platform.WebServer; import static com.google.common.base.Preconditions.checkState; import static com.google.common.collect.ImmutableList.copyOf; -import static org.sonar.server.health.Health.newHealthCheckBuilder; /** * Implementation of {@link HealthChecker} based on {@link NodeHealthCheck} and {@link ClusterHealthCheck} instances @@ -81,35 +78,4 @@ public class HealthCheckerImpl implements HealthChecker { return new ClusterHealth(health, nodeHealths); } - private enum HealthReducer implements BinaryOperator<Health> { - INSTANCE; - - /** - * According to Javadoc, {@link BinaryOperator} used in method - * {@link java.util.stream.Stream#reduce(Object, BinaryOperator)} is supposed to be stateless. - * - * But as we are sure this {@link BinaryOperator} won't be used on a Stream with {@link Stream#parallel()} - * feature on, we allow ourselves this optimisation. - */ - private final Health.Builder builder = newHealthCheckBuilder(); - - @Override - public Health apply(Health left, Health right) { - builder.clear(); - builder.setStatus(worseOf(left.getStatus(), right.getStatus())); - left.getCauses().forEach(builder::addCause); - right.getCauses().forEach(builder::addCause); - return builder.build(); - } - - private static Health.Status worseOf(Health.Status left, Health.Status right) { - if (left == right) { - return left; - } - if (left.ordinal() > right.ordinal()) { - return left; - } - return right; - } - } } diff --git a/server/sonar-server/src/main/java/org/sonar/server/health/HealthReducer.java b/server/sonar-server/src/main/java/org/sonar/server/health/HealthReducer.java new file mode 100644 index 00000000000..3767d180d14 --- /dev/null +++ b/server/sonar-server/src/main/java/org/sonar/server/health/HealthReducer.java @@ -0,0 +1,57 @@ +/* + * SonarQube + * Copyright (C) 2009-2017 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.health; + +import java.util.function.BinaryOperator; +import java.util.stream.Stream; + +import static org.sonar.server.health.Health.newHealthCheckBuilder; + +public enum HealthReducer implements BinaryOperator<Health> { + INSTANCE; + + /** + * According to Javadoc, {@link BinaryOperator} used in method + * {@link java.util.stream.Stream#reduce(Object, BinaryOperator)} is supposed to be stateless. + * + * But as we are sure this {@link BinaryOperator} won't be used on a Stream with {@link Stream#parallel()} + * feature on, we allow ourselves this optimisation. + */ + private final Health.Builder builder = newHealthCheckBuilder(); + + @Override + public Health apply(Health left, Health right) { + builder.clear(); + builder.setStatus(worseOf(left.getStatus(), right.getStatus())); + left.getCauses().forEach(builder::addCause); + right.getCauses().forEach(builder::addCause); + return builder.build(); + } + + private static Health.Status worseOf(Health.Status left, Health.Status right) { + if (left == right) { + return left; + } + if (left.ordinal() > right.ordinal()) { + return left; + } + return right; + } +} diff --git a/server/sonar-server/src/main/java/org/sonar/server/platform/ws/HealthActionModule.java b/server/sonar-server/src/main/java/org/sonar/server/platform/ws/HealthActionModule.java index f73abfe4591..0985a9dda9c 100644 --- a/server/sonar-server/src/main/java/org/sonar/server/platform/ws/HealthActionModule.java +++ b/server/sonar-server/src/main/java/org/sonar/server/platform/ws/HealthActionModule.java @@ -20,14 +20,21 @@ package org.sonar.server.platform.ws; import org.sonar.core.platform.Module; +import org.sonar.server.health.AppNodeClusterCheck; import org.sonar.server.health.CeStatusNodeCheck; import org.sonar.server.health.DbConnectionNodeCheck; import org.sonar.server.health.EsStatusClusterCheck; import org.sonar.server.health.EsStatusNodeCheck; import org.sonar.server.health.HealthCheckerImpl; import org.sonar.server.health.WebServerStatusNodeCheck; +import org.sonar.server.platform.WebServer; public class HealthActionModule extends Module { + private final WebServer webServer; + + public HealthActionModule(WebServer webServer) { + this.webServer = webServer; + } @Override protected void configureModule() { @@ -36,9 +43,11 @@ public class HealthActionModule extends Module { DbConnectionNodeCheck.class, EsStatusNodeCheck.class, CeStatusNodeCheck.class); - - // ClusterHealthCheck implementations - add(EsStatusClusterCheck.class); + if (!webServer.isStandalone()) { + // ClusterHealthCheck implementations + add(EsStatusClusterCheck.class, + AppNodeClusterCheck.class); + } add(HealthCheckerImpl.class, HealthActionSupport.class, diff --git a/server/sonar-server/src/test/java/org/sonar/server/health/AppNodeClusterCheckTest.java b/server/sonar-server/src/test/java/org/sonar/server/health/AppNodeClusterCheckTest.java new file mode 100644 index 00000000000..02b627f59e9 --- /dev/null +++ b/server/sonar-server/src/test/java/org/sonar/server/health/AppNodeClusterCheckTest.java @@ -0,0 +1,353 @@ +/* + * SonarQube + * Copyright (C) 2009-2017 SonarSource SA + * mailto:info AT sonarsource DOT com + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3 of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ +package org.sonar.server.health; + +import com.google.common.collect.ImmutableList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Objects; +import java.util.Random; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; +import javax.annotation.Nullable; +import org.assertj.core.api.AbstractAssert; +import org.junit.Test; +import org.sonar.cluster.health.NodeDetails; +import org.sonar.cluster.health.NodeHealth; + +import static java.util.stream.Collectors.toSet; +import static java.util.stream.Stream.of; +import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric; +import static org.sonar.cluster.health.NodeHealth.Status.GREEN; +import static org.sonar.cluster.health.NodeHealth.Status.RED; +import static org.sonar.cluster.health.NodeHealth.Status.YELLOW; + +public class AppNodeClusterCheckTest { + private final Random random = new Random(); + + private AppNodeClusterCheck underTest = new AppNodeClusterCheck(); + + @Test + public void status_RED_when_no_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths().collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.RED) + .andCauses("No application node"); + } + + @Test + public void status_RED_when_single_RED_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(RED).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.RED) + .andCauses("Status of all application nodes is RED", + "There should be at least two application nodes"); + } + + @Test + public void status_YELLOW_when_single_YELLOW_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(YELLOW).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses( + "Status of all application nodes is YELLOW", + "There should be at least two application nodes"); + } + + @Test + public void status_YELLOW_when_single_GREEN_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(GREEN).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses("There should be at least two application nodes"); + } + + @Test + public void status_RED_when_two_RED_application_nodes() { + Set<NodeHealth> nodeHealths = nodeHealths(RED, RED).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.RED) + .andCauses("Status of all application nodes is RED"); + } + + @Test + public void status_YELLOW_when_two_YELLOW_application_nodes() { + Set<NodeHealth> nodeHealths = nodeHealths(YELLOW, YELLOW).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses("Status of all application nodes is YELLOW"); + } + + @Test + public void status_YELLOW_when_one_RED_node_and_one_YELLOW_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(RED, YELLOW).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses( + "At least one application node is RED", + "At least one application node is YELLOW"); + } + + @Test + public void status_YELLOW_when_one_RED_node_and_one_GREEN_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(RED, GREEN).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses("At least one application node is RED"); + } + + @Test + public void status_YELLOW_when_one_YELLOW_node_and_one_GREEN_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(YELLOW, GREEN).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses("At least one application node is YELLOW"); + } + + @Test + public void status_GREEN_when_two_GREEN_application_node() { + Set<NodeHealth> nodeHealths = nodeHealths(GREEN, GREEN).collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.GREEN) + .andCauses(); + } + + @Test + public void status_GREEN_when_two_GREEN_application_node_and_any_number_of_other_is_GREEN() { + Set<NodeHealth> nodeHealths = of( + // at least 1 extra GREEN + of(appNodeHealth(GREEN)), + // 0 to 10 GREEN + randomNumberOfAppNodeHealthOfAnyStatus(GREEN), + // 2 GREEN + nodeHealths(GREEN, GREEN)) + .flatMap(s -> s) + .collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.GREEN) + .andCauses(); + } + + @Test + public void status_YELLOW_when_two_GREEN_application_node_and_any_number_of_other_is_YELLOW_or_GREEN() { + Set<NodeHealth> nodeHealths = of( + // at least 1 YELLOW + of(appNodeHealth(YELLOW)), + // 0 to 10 YELLOW/GREEN + randomNumberOfAppNodeHealthOfAnyStatus(GREEN, YELLOW), + // 2 GREEN + nodeHealths(GREEN, GREEN)) + .flatMap(s -> s) + .collect(toSet()); + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses("At least one application node is YELLOW"); + } + + @Test + public void status_YELLOW_when_two_GREEN_application_node_and_any_number_of_other_is_RED_or_GREEN() { + Set<NodeHealth> nodeHealths = of( + // at least 1 RED + of(appNodeHealth(RED)), + // 0 to 10 RED/GREEN + randomNumberOfAppNodeHealthOfAnyStatus(GREEN, RED), + // 2 GREEN + nodeHealths(GREEN, GREEN)) + .flatMap(s -> s) + .collect(toSet()); + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses("At least one application node is RED"); + } + + @Test + public void status_YELLOW_when_two_GREEN_application_node_and_any_number_of_other_is_either_RED_or_YELLOW() { + Set<NodeHealth> nodeHealths = of( + // at least 1 RED + of(appNodeHealth(RED)), + // at least 1 YELLOW + of(appNodeHealth(YELLOW)), + // 0 to 10 RED/YELLOW/GREEN + randomNumberOfAppNodeHealthOfAnyStatus(RED, YELLOW, GREEN), + // 2 GREEN + nodeHealths(GREEN, GREEN)) + .flatMap(s -> s) + .collect(toSet()); + + Health check = underTest.check(nodeHealths); + + assertThat(check) + .forInput(nodeHealths) + .hasStatus(Health.Status.YELLOW) + .andCauses( + "At least one application node is YELLOW", + "At least one application node is RED"); + } + + /** + * Between 0 and 10 NodeHealth of Application node with any of the specified statuses. + */ + private Stream<NodeHealth> randomNumberOfAppNodeHealthOfAnyStatus(NodeHealth.Status... randomStatuses) { + return IntStream.range(0, random.nextInt(10)) + .mapToObj(i -> appNodeHealth(randomStatuses[random.nextInt(randomStatuses.length)])); + } + + private Stream<NodeHealth> nodeHealths(NodeHealth.Status... appNodeStatuses) { + return of( + // random number of Search nodes with random status + IntStream.range(0, random.nextInt(3)) + .mapToObj(i -> appNodeHealth(NodeDetails.Type.SEARCH, NodeHealth.Status.values()[random.nextInt(NodeHealth.Status.values().length)])), + Arrays.stream(appNodeStatuses).map(this::appNodeHealth)) + .flatMap(s -> s); + } + + private NodeHealth appNodeHealth(NodeHealth.Status status) { + return appNodeHealth(NodeDetails.Type.APPLICATION, status); + } + + private NodeHealth appNodeHealth(NodeDetails.Type type, NodeHealth.Status status) { + return NodeHealth.newNodeHealthBuilder() + .setStatus(status) + .setDetails(NodeDetails.newNodeDetailsBuilder() + .setType(type) + .setHost(randomAlphanumeric(32)) + .setName(randomAlphanumeric(32)) + .setPort(1 + random.nextInt(88)) + .setStarted(1 + random.nextInt(54)) + .build()) + .setDate(1 + random.nextInt(2323)) + .build(); + } + + public static HealthAssert assertThat(Health actual) { + return new HealthAssert(actual); + } + + private static final class HealthAssert extends AbstractAssert<HealthAssert, Health> { + private Set<NodeHealth> nodeHealths; + + protected HealthAssert(Health actual) { + super(actual, HealthAssert.class); + } + + public HealthAssert forInput(Set<NodeHealth> nodeHealths) { + this.nodeHealths = nodeHealths; + + return this; + } + + public HealthAssert hasStatus(Health.Status expected) { + isNotNull(); + + if (actual.getStatus() != expected) { + failWithMessage( + "Expected Status of Health to be <%s> but was <%s> for NodeHealth \n%s", + expected, + actual.getStatus(), + printStatusesAndTypes(this.nodeHealths)); + } + + return this; + } + + public HealthAssert andCauses(String... causes) { + isNotNull(); + + if (!checkCauses(causes)) { + failWithMessage( + "Expected causes of Health to contain only \n%s\n but was \n%s\n for NodeHealth \n%s", + Arrays.asList(causes), + actual.getCauses(), + printStatusesAndTypes(this.nodeHealths)); + } + + return this; + } + + private String printStatusesAndTypes(@Nullable Set<NodeHealth> nodeHealths) { + if (nodeHealths == null) { + return "<null>"; + } + return nodeHealths.stream() + .map(s -> ImmutableList.of(s.getDetails().getType().name(), s.getStatus().name())) + .map(String::valueOf) + .collect(Collectors.joining(",")); + } + + private boolean checkCauses(String... causes) { + if (causes.length != this.actual.getCauses().size()) { + return false; + } + return Objects.equals(new HashSet<>(Arrays.asList(causes)), this.actual.getCauses()); + } + } +} diff --git a/server/sonar-server/src/test/java/org/sonar/server/platform/ws/HealthActionModuleTest.java b/server/sonar-server/src/test/java/org/sonar/server/platform/ws/HealthActionModuleTest.java index e3090b0afef..e4ac3a8448e 100644 --- a/server/sonar-server/src/test/java/org/sonar/server/platform/ws/HealthActionModuleTest.java +++ b/server/sonar-server/src/test/java/org/sonar/server/platform/ws/HealthActionModuleTest.java @@ -21,10 +21,12 @@ package org.sonar.server.platform.ws; import java.util.Collection; import java.util.List; +import java.util.Random; import java.util.stream.Collectors; import org.junit.Test; import org.picocontainer.ComponentAdapter; import org.sonar.core.platform.ComponentContainer; +import org.sonar.server.health.AppNodeClusterCheck; import org.sonar.server.health.CeStatusNodeCheck; import org.sonar.server.health.ClusterHealthCheck; import org.sonar.server.health.DbConnectionNodeCheck; @@ -33,19 +35,26 @@ import org.sonar.server.health.EsStatusNodeCheck; import org.sonar.server.health.HealthCheckerImpl; import org.sonar.server.health.NodeHealthCheck; import org.sonar.server.health.WebServerStatusNodeCheck; +import org.sonar.server.platform.WebServer; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; public class HealthActionModuleTest { - private HealthActionModule underTest = new HealthActionModule(); + private WebServer webServer = mock(WebServer.class); + private HealthActionModule underTest = new HealthActionModule(webServer); @Test public void verify_action_and_HealthChecker() { + boolean standalone = new Random().nextBoolean(); + when(webServer.isStandalone()).thenReturn(standalone); ComponentContainer container = new ComponentContainer(); underTest.configure(container); assertThat(classesAddedToContainer(container)) + .describedAs("Verifying action and HealthChecker with standalone=%s", standalone) .contains(HealthCheckerImpl.class) .contains(HealthActionSupport.class) .contains(HealthAction.class) @@ -54,6 +63,8 @@ public class HealthActionModuleTest { @Test public void verify_installed_NodeHealthChecks_implementations() { + boolean standalone = new Random().nextBoolean(); + when(webServer.isStandalone()).thenReturn(standalone); ComponentContainer container = new ComponentContainer(); underTest.configure(container); @@ -68,15 +79,28 @@ public class HealthActionModuleTest { } @Test - public void verify_installed_ClusterHealthChecks_implementations() { + public void verify_installed_ClusterHealthChecks_implementations_in_standalone() { + when(webServer.isStandalone()).thenReturn(true); + ComponentContainer container = new ComponentContainer(); + + underTest.configure(container); + + List<Class<?>> checks = classesAddedToContainer(container).stream().filter(ClusterHealthCheck.class::isAssignableFrom).collect(Collectors.toList()); + assertThat(checks).isEmpty(); + } + + @Test + public void verify_installed_ClusterHealthChecks_implementations_in_clustering() { + when(webServer.isStandalone()).thenReturn(false); ComponentContainer container = new ComponentContainer(); underTest.configure(container); List<Class<?>> checks = classesAddedToContainer(container).stream().filter(ClusterHealthCheck.class::isAssignableFrom).collect(Collectors.toList()); assertThat(checks) - .hasSize(1) - .contains(EsStatusClusterCheck.class); + .hasSize(2) + .contains(EsStatusClusterCheck.class) + .contains(AppNodeClusterCheck.class); } private List<Class<?>> classesAddedToContainer(ComponentContainer container) { |