org.eclipse.microprofile.health.HealthCheck Java Examples

public HealthCheckModel performHealthChecks() {
    Instance<HealthCheck> healthChecks = this.healthChecks;
    if (requireAnnotation) {
        healthChecks = this.healthChecks.select(HealthLiteral.INSTANCE);
    }
    List<HealthCheck> healthCheckBeans = healthChecks.stream()
            .collect(toList());

    List<HealthResultModel> results = healthCheckBeans.stream()
            .map(HealthCheck::call)
            .map(r -> new HealthResultModel(r.getName(), r.getState().name(), r.getData().orElse(emptyMap())))
            .collect(toList());
    boolean anyDown = results.stream().anyMatch(r -> r.getState().equalsIgnoreCase(HealthCheckResponse.State.DOWN.name()));
    try {
        if (anyDown) {
            return toModel(HealthCheckResponse.State.DOWN, results);
        } else {
            return toModel(HealthCheckResponse.State.UP, results);
        }
    }
    finally {
        healthCheckBeans.forEach(healthChecks::destroy);
    }
}
 

/**
 * Test metadata on HealthCheck procedure beans
 */
@Test
public void testHealthCheckMetadata() {
    Instance<HealthCheck> selects;

    selects = checks.select(Liveness.Literal.INSTANCE);
    Assertions.assertTrue(isUnique(selects));

    selects = checks.select(Readiness.Literal.INSTANCE);
    Assertions.assertTrue(isUnique(selects));

    selects = checks.select(HealthGroup.Literal.of("group1"));
    Assertions.assertTrue(isUnique(selects));

    selects = checks.select(HealthGroup.Literal.of("group2"));
    Assertions.assertTrue(isUnique(selects));

    selects = checks.select(Liveness.Literal.INSTANCE,
            Readiness.Literal.INSTANCE,
            HealthGroup.Literal.of("group1"),
            HealthGroup.Literal.of("group2"));
    Assertions.assertTrue(isUnique(selects));

    Assertions.assertTrue(checks.select(HealthGroup.Literal.of("group3")).isUnsatisfied());

}
 

@Test
public void testUrlCheckIncorrectStatusCode() {
    final HealthCheck urlHealthCheck = new UrlHealthCheck("http://www.google.com")
            .statusCode(HttpURLConnection.HTTP_CREATED);
    final HealthCheckResponse healthCheckResponse = urlHealthCheck.call();

    assertEquals(HealthCheckResponse.State.DOWN, healthCheckResponse.getState());
    assertEquals("Expected response code 201 but actual is 200", healthCheckResponse.getData().get().get("error"));
}
 

@Test
public void testHealthBeans() {
    List<HealthCheck> check = new ArrayList<>();
    for (HealthCheck i : checks) {
        check.add(i);
    }
    assertEquals(1, check.size());
    assertEquals(HealthCheckResponse.State.DOWN, check.get(0).call().getState());
}
 

@Test
void testHealthy() throws SQLException {
    final DataSource mockDataSource = mock(DataSource.class);
    final Connection mockConnection = mock(Connection.class);
    when(mockDataSource.getConnection()).thenReturn(mockConnection);
    when(mockConnection.isClosed()).thenReturn(false);

    final HealthCheck check = new DBHealthCheck(mockDataSource);
    assertEquals(HealthCheckResponse.State.UP, check.call().getState(), "Database connection isn't healthy!");
}
 

@Test
void testThrowsUnhealthy() throws SQLException {
    final DataSource mockDataSource = mock(DataSource.class);
    doThrow(SQLException.class).when(mockDataSource).getConnection();

    final HealthCheck check = new DBHealthCheck(mockDataSource);
    assertEquals(HealthCheckResponse.State.DOWN, check.call().getState(), "Database connection isn't healthy!");
}
 

@Experimental("Asynchronous Health Check procedures and Health Groups")
public Uni<SmallRyeHealth> getHealthGroupsAsync() {
    List<Uni<HealthCheckResponse>> checks = new ArrayList<>();
    initUnis(checks, getHealthGroupsChecks(HealthCheck.class), getHealthGroupsChecks(AsyncHealthCheck.class));

    return getHealthAsync(checks);
}
 

private void initUnis(List<Uni<HealthCheckResponse>> list, Iterable<HealthCheck> checks,
        Iterable<AsyncHealthCheck> asyncChecks) {
    for (HealthCheck check : checks) {
        list.add(callSync(check));
    }

    for (AsyncHealthCheck asyncCheck : asyncChecks) {
        list.add(callAsync(asyncCheck));
    }
}
 

@Test
void testUnhealthy() throws SQLException {
    final DataSource mockDataSource = mock(DataSource.class);
    final Connection mockConnection = mock(Connection.class);
    when(mockDataSource.getConnection()).thenReturn(mockConnection);
    when(mockConnection.isClosed()).thenReturn(true);

    final HealthCheck check = new DBHealthCheck(mockDataSource);
    assertEquals(HealthCheckResponse.State.DOWN, check.call().getState(),
            "Database connection doesn't report as unhealthy!");
}
 

@Test
void testHealthy() {
    final Dataset dataset = rdf.createDataset();
    final RDFConnection rdfConnection = connect(wrap(toJena(dataset)));
    final HealthCheck check = new TriplestoreHealthCheck(rdfConnection);
    assertEquals(HealthCheckResponse.State.UP, check.call().getState(), "RDFConnection isn't healthy!");
}
 

@Test
void testUnhealthy() {
    final Dataset dataset = rdf.createDataset();
    final RDFConnection rdfConnection = connect(wrap(toJena(dataset)));
    rdfConnection.close();
    final HealthCheck check = new TriplestoreHealthCheck(rdfConnection);
    assertEquals(HealthCheckResponse.State.DOWN, check.call().getState(),
            "Closed RDFConnection doesn't report as unhealthy!");
}
 

private Uni<HealthCheckResponse> callSync(HealthCheck healthCheck) {
    return withRecovery(healthCheck.getClass().getName(), Uni.createFrom().item(healthCheck::call));
}
 

public void addHealthCheck(HealthCheck check) {
    if (check != null) {
        additionalChecks.put(check.getClass().getName(), callSync(check));
        additionalListsChanged = true;
    }
}
 

public void removeHealthCheck(HealthCheck check) {
    additionalChecks.remove(check.getClass().getName());
    additionalListsChanged = true;
}
 

@Test
void testUnhealthyDefault() {
    final HealthCheck check = new TriplestoreHealthCheck();
    assertEquals(HealthCheckResponse.State.DOWN, check.call().getState(), "RDFConnection isn't healthy!");
}
 

@Test
void testUnhealthyDefault() {
    final HealthCheck check = new DBHealthCheck();
    assertEquals(HealthCheckResponse.State.DOWN, check.call().getState(), "Database connection isn't healthy!");
}
 

@Produces
@Liveness
HealthCheck serverCheck() {
    return () -> KEYCLOAK_SERVER_HEALTH_CHECK.up().build();
}
 

@Produces
@Readiness
HealthCheck cdiProducedReadinessCheck() {
    return () -> HealthCheckResponse.down("cdi-produced-failed-check");
}
 

@Readiness
HealthCheck alpha() {
    int idx = ALPHA_COUNTER.incrementAndGet();
    return () -> HealthCheckResponse.builder().up().name("alpha" + idx).build();
}
 

@Dependent
@Readiness
HealthCheck bravo() {
    int idx = BRAVO_COUNTER.incrementAndGet();
    return () -> HealthCheckResponse.builder().up().name("bravo" + idx).build();
}
 

@Produces
@Liveness
HealthCheck cdiProducedLivenessCheck() {
    return () -> HealthCheckResponse.up("cdi-produced-successful-check");
}
 

@Test
public void testBooleanSupplierHealthStatus() {

    final HealthCheck myHealth = HealthStatus.state("myHealth", () -> true);

    final HealthCheckResponse healthCheckResponse = myHealth.call();

    assertThat(healthCheckResponse.getName(), is("myHealth"));
    assertThat(healthCheckResponse.getState(), is(HealthCheckResponse.State.UP));

}
 

@Test
public void testBooleanHealthStatus() {

    final HealthCheck myHealth = HealthStatus.state("myHealth", true);

    final HealthCheckResponse healthCheckResponse = myHealth.call();

    assertThat(healthCheckResponse.getName(), is("myHealth"));
    assertThat(healthCheckResponse.getState(), is(HealthCheckResponse.State.UP));

}
 

@Test
public void testRandomNameHealthStatus() {

    final HealthCheck healthCheck = HealthStatus.state(true);

    final HealthCheckResponse healthCheckResponse = healthCheck.call();

    assertThat(healthCheckResponse.getName(), startsWith("unnamed-health-check-"));
}
 

@Test
public void testHealthStatusDown() {

    final HealthCheck myHealth = HealthStatus.down("myHealth");

    final HealthCheckResponse healthCheckResponse = myHealth.call();

    assertThat(healthCheckResponse.getName(), is("myHealth"));
    assertThat(healthCheckResponse.getState(), is(HealthCheckResponse.State.DOWN));
}
 

@Test
public void testHealthStatusUp() {

    final HealthCheck myHealth = HealthStatus.up("myHealth");

    final HealthCheckResponse healthCheckResponse = myHealth.call();

    assertThat(healthCheckResponse.getName(), is("myHealth"));
    assertThat(healthCheckResponse.getState(), is(HealthCheckResponse.State.UP));
}
 

@Produces
@Readiness
HealthCheck databaseCheck() {

    HealthCheckResponseBuilder databaseHealth = HealthCheckResponse.named("keycloak:database");

    boolean databaseReady = isDatabaseReady();

    return () -> (databaseReady ? databaseHealth.up() : databaseHealth.down()).build();
}
 

/**
 * Creates a health check with given state and health check name.
 * 
 * @param name of the state.
 * @param supplier to get state.
 * @return Health check with given state and name.
 */
public static HealthCheck state(String name, BooleanSupplier supplier) {
    return state(name, supplier.getAsBoolean());
}
 

/**
 * Creates a health check with state set from supplier and default health check name (health-check).
 * 
 * @param supplier to get state.
 * @return Health check with given state and default name.
 */
public static HealthCheck state(BooleanSupplier supplier) {
    return state(supplier.getAsBoolean());
}
 

/**
 * Creates a health check with state down.
 * 
 * @param name of the health check
 * @return Health check with state down and given name.
 */
public static HealthCheck down(String name) {
    return state(name, false);
}