@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; } },
public Health build() { checkStatus(this.status); return new Health(this); }
@Test public void getStatus_returns_status_from_builder() { Health underTest = newHealthCheckBuilder().setStatus(anyStatus).build(); assertThat(underTest.getStatus()).isEqualTo(anyStatus); }
@Test public void hashcode_is_based_on_status_and_causes() { Health.Builder builder1 = newHealthCheckBuilder(); Health.Builder builder2 = newHealthCheckBuilder(); builder1.setStatus(anyStatus); builder2.setStatus(anyStatus); randomCauses.forEach(s -> { builder1.addCause(s); builder2.addCause(s); }); assertThat(builder1.build().hashCode()) .isEqualTo(builder1.build().hashCode()) .isEqualTo(builder2.build().hashCode()) .isEqualTo(builder2.build().hashCode()); }
@Test public void getCause_returns_causes_from_builder() { Health.Builder builder = newHealthCheckBuilder().setStatus(anyStatus); randomCauses.forEach(builder::addCause); Health underTest = builder.build(); assertThat(underTest.getCauses()) .isEqualTo(randomCauses); }
@Test public void checkNode_returns_YELLOW_status_if_only_GREEN_and_at_least_one_YELLOW_statuses_returned_by_NodeHealthCheck() { List<Health.Status> statuses = new ArrayList<>(); Stream.concat( IntStream.range(0, 1 + random.nextInt(20)).mapToObj(i -> YELLOW), // at least 1 YELLOW IntStream.range(0, random.nextInt(20)).mapToObj(i -> GREEN)).forEach(statuses::add); // between 0 and 19 GREEN Collections.shuffle(statuses); HealthCheckerImpl underTest = newNodeHealthCheckerImpl(statuses.stream()); assertThat(underTest.checkNode().getStatus()) .describedAs("%s should have been computed from %s statuses", YELLOW, statuses) .isEqualTo(YELLOW); }
@Test public void verify_toString() { assertThat(Health.GREEN.toString()).isEqualTo("Health{GREEN, causes=[]}"); Health.Builder builder = newHealthCheckBuilder().setStatus(anyStatus); randomCauses.forEach(builder::addCause); String underTest = builder.build().toString(); AbstractCharSequenceAssert<?, String> a = assertThat(underTest) .describedAs("toString for status %s and causes %s", anyStatus, randomCauses); if (randomCauses.isEmpty()) { a.isEqualTo("Health{" + anyStatus + ", causes=[]}"); } else if (randomCauses.size() == 1) { a.isEqualTo("Health{" + anyStatus + ", causes=[" + randomCauses.iterator().next() + "]}"); } else { a.startsWith("Health{" + anyStatus + ", causes=[") .endsWith("]}") .contains(randomCauses); } }
@Test public void request_returns_status_and_causes_from_HealthChecker_checkNode_method_when_standalone() { authenticateWithRandomMethod(); Health.Status randomStatus = Health.Status.values()[new Random().nextInt(Health.Status.values().length)]; Health.Builder builder = newHealthCheckBuilder() .setStatus(randomStatus); IntStream.range(0, new Random().nextInt(5)).mapToObj(i -> RandomStringUtils.randomAlphanumeric(3)).forEach(builder::addCause); Health health = builder.build(); when(healthChecker.checkNode()).thenReturn(health); when(webServer.isStandalone()).thenReturn(true); TestRequest request = underTest.newRequest(); System.HealthResponse healthResponse = request.executeProtobuf(System.HealthResponse.class); assertThat(healthResponse.getHealth().name()).isEqualTo(randomStatus.name()); assertThat(health.getCauses()).isEqualTo(health.getCauses()); }
@Test public void equals_is_based_on_content() { Health health = randomHealth(); Set<NodeHealth> nodeHealths = randomNodeHealths(); ClusterHealth underTest = new ClusterHealth(health, nodeHealths); assertThat(underTest) .isEqualTo(underTest) .isEqualTo(new ClusterHealth(health, nodeHealths)) .isNotEqualTo(new Object()) .isNotEqualTo(null) .isNotEqualTo(new ClusterHealth( newHealthCheckBuilder() .setStatus(health.getStatus()) .addCause("foo_bar") .build(), randomNodeHealths())) .isNotEqualTo(new ClusterHealth( health, concat(nodeHealths.stream(), Stream.of(randomNodeHealth())).collect(toSet()))); }
@Test public void checkNode_returns_causes_of_all_NodeHealthCheck_whichever_their_status() { NodeHealthCheck[] nodeHealthChecks = IntStream.range(0, 1 + random.nextInt(20)) .mapToObj(s -> new HardcodedHealthNodeCheck(IntStream.range(0, random.nextInt(3)).mapToObj(i -> randomAlphanumeric(3)).toArray(String[]::new))) .map(NodeHealthCheck.class::cast) .toArray(NodeHealthCheck[]::new); String[] expected = Arrays.stream(nodeHealthChecks).map(NodeHealthCheck::check).flatMap(s -> s.getCauses().stream()).toArray(String[]::new); HealthCheckerImpl underTest = new HealthCheckerImpl(webServer, nodeHealthChecks); assertThat(underTest.checkNode().getCauses()).containsOnly(expected); }
@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; } },
@Test public void request_returns_status_and_causes_from_HealthChecker_checkNode_method() { authenticateWithPasscode(); Health.Status randomStatus = Health.Status.values()[new Random().nextInt(Health.Status.values().length)]; Health.Builder builder = newHealthCheckBuilder() .setStatus(randomStatus); IntStream.range(0, new Random().nextInt(5)).mapToObj(i -> RandomStringUtils.randomAlphanumeric(3)).forEach(builder::addCause); Health health = builder.build(); when(healthChecker.checkNode()).thenReturn(health); TestRequest request = underTest.newRequest(); System.HealthResponse healthResponse = request.executeProtobuf(System.HealthResponse.class); assertThat(healthResponse.getHealth().name()).isEqualTo(randomStatus.name()); assertThat(health.getCauses()).isEqualTo(health.getCauses()); }
@Test public void checkCluster_returns_YELLOW_status_if_only_GREEN_and_at_least_one_YELLOW_statuses_returned_by_ClusterHealthChecks() { when(webServer.isStandalone()).thenReturn(false); List<Health.Status> statuses = new ArrayList<>(); Stream.concat( IntStream.range(0, 1 + random.nextInt(20)).mapToObj(i -> YELLOW), // at least 1 YELLOW IntStream.range(0, random.nextInt(20)).mapToObj(i -> GREEN)).forEach(statuses::add); // between 0 and 19 GREEN Collections.shuffle(statuses); HealthCheckerImpl underTest = newClusterHealthCheckerImpl(statuses.stream()); assertThat(underTest.checkCluster().getHealth().getStatus()) .describedAs("%s should have been computed from %s statuses", YELLOW, statuses) .isEqualTo(YELLOW); }
@Test public void checkCluster_returns_causes_of_all_ClusterHealthChecks_whichever_their_status() { when(webServer.isStandalone()).thenReturn(false); List<String[]> causesGroups = IntStream.range(0, 1 + random.nextInt(20)) .mapToObj(s -> IntStream.range(0, random.nextInt(3)).mapToObj(i -> randomAlphanumeric(3)).toArray(String[]::new)) .collect(Collectors.toList()); ClusterHealthCheck[] clusterHealthChecks = causesGroups.stream() .map(HardcodedHealthClusterCheck::new) .map(ClusterHealthCheck.class::cast) .toArray(ClusterHealthCheck[]::new); String[] expectedCauses = causesGroups.stream().flatMap(Arrays::stream).collect(Collectors.toSet()).stream().toArray(String[]::new); HealthCheckerImpl underTest = new HealthCheckerImpl(webServer, new NodeHealthCheck[0], clusterHealthChecks, sharedHealthState); assertThat(underTest.checkCluster().getHealth().getCauses()).containsOnly(expectedCauses); }
public Health build() { checkStatus(this.status); return new Health(this); }