package org.jooby.metrics;
import static org.easymock.EasyMock.expect;
import java.util.Optional;
import java.util.SortedMap;
import org.jooby.Mutant;
import org.jooby.Request;
import org.jooby.Response;
import org.jooby.Status;
import org.jooby.test.MockUnit;
import org.jooby.test.MockUnit.Block;
import org.junit.Test;
import com.codahale.metrics.health.HealthCheck.Result;
import com.codahale.metrics.health.HealthCheckRegistry;
import com.google.common.collect.ImmutableSortedMap;
public class HealthCheckHandlerTest {
private Block registry = unit -> {
Request request = unit.get(Request.class);
expect(request.require(HealthCheckRegistry.class))
.andReturn(unit.get(HealthCheckRegistry.class));
};
private Block param(final String name, final Optional<String> value) {
return unit -> {
Request req = unit.get(Request.class);
Mutant mvalue = unit.mock(Mutant.class);
expect(mvalue.toOptional()).andReturn(value);
expect(req.param(name)).andReturn(mvalue);
};
}
@Test
public void notImplemented() throws Exception {
SortedMap<String, Result> checks = ImmutableSortedMap.of();
new MockUnit(Request.class, Response.class, HealthCheckRegistry.class)
.expect(registry)
.expect(param("name", Optional.empty()))
.expect(unit -> {
HealthCheckRegistry registry = unit.get(HealthCheckRegistry.class);
expect(registry.runHealthChecks()).andReturn(checks);
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status(Status.NOT_IMPLEMENTED)).andReturn(rsp);
expect(rsp.header("Cache-Control", "must-revalidate,no-cache,no-store")).andReturn(rsp);
rsp.send(checks);
})
.run(unit -> {
new HealthCheckHandler().handle(unit.get(Request.class), unit.get(Response.class));
});
}
@Test
public void allchecks() throws Exception {
SortedMap<String, Result> checks = ImmutableSortedMap.of("c1", Result.healthy(), "c2",
Result.healthy());
new MockUnit(Request.class, Response.class, HealthCheckRegistry.class)
.expect(registry)
.expect(param("name", Optional.empty()))
.expect(unit -> {
HealthCheckRegistry registry = unit.get(HealthCheckRegistry.class);
expect(registry.runHealthChecks()).andReturn(checks);
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status(Status.OK)).andReturn(rsp);
expect(rsp.header("Cache-Control", "must-revalidate,no-cache,no-store")).andReturn(rsp);
rsp.send(checks);
})
.run(unit -> {
new HealthCheckHandler().handle(unit.get(Request.class), unit.get(Response.class));
});
}
@Test
public void allchecksErrOnFirst() throws Exception {
SortedMap<String, Result> checks = ImmutableSortedMap.of(
"c1", Result.unhealthy("intentional err"),
"c2", Result.healthy());
new MockUnit(Request.class, Response.class, HealthCheckRegistry.class)
.expect(registry)
.expect(param("name", Optional.empty()))
.expect(unit -> {
HealthCheckRegistry registry = unit.get(HealthCheckRegistry.class);
expect(registry.runHealthChecks()).andReturn(checks);
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status(Status.SERVER_ERROR)).andReturn(rsp);
expect(rsp.header("Cache-Control", "must-revalidate,no-cache,no-store")).andReturn(rsp);
rsp.send(checks);
})
.run(unit -> {
new HealthCheckHandler().handle(unit.get(Request.class), unit.get(Response.class));
});
}
@Test
public void allchecksErrOnLast() throws Exception {
SortedMap<String, Result> checks = ImmutableSortedMap.of("c1", Result.healthy(), "c2",
Result.unhealthy("intentional err"));
new MockUnit(Request.class, Response.class, HealthCheckRegistry.class)
.expect(registry)
.expect(param("name", Optional.empty()))
.expect(unit -> {
HealthCheckRegistry registry = unit.get(HealthCheckRegistry.class);
expect(registry.runHealthChecks()).andReturn(checks);
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status(Status.SERVER_ERROR)).andReturn(rsp);
expect(rsp.header("Cache-Control", "must-revalidate,no-cache,no-store")).andReturn(rsp);
rsp.send(checks);
})
.run(unit -> {
new HealthCheckHandler().handle(unit.get(Request.class), unit.get(Response.class));
});
}
@Test
public void allchecksErrOnMiddle() throws Exception {
SortedMap<String, Result> checks = ImmutableSortedMap.of("c1", Result.healthy(), "c2",
Result.unhealthy("intentional err"), "c3", Result.healthy());
new MockUnit(Request.class, Response.class, HealthCheckRegistry.class)
.expect(registry)
.expect(param("name", Optional.empty()))
.expect(unit -> {
HealthCheckRegistry registry = unit.get(HealthCheckRegistry.class);
expect(registry.runHealthChecks()).andReturn(checks);
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status(Status.SERVER_ERROR)).andReturn(rsp);
expect(rsp.header("Cache-Control", "must-revalidate,no-cache,no-store")).andReturn(rsp);
rsp.send(checks);
})
.run(unit -> {
new HealthCheckHandler().handle(unit.get(Request.class), unit.get(Response.class));
});
}
@Test
public void somechecks() throws Exception {
Result check = Result.healthy();
SortedMap<String, Result> checks = ImmutableSortedMap.of("c", check);
new MockUnit(Request.class, Response.class, HealthCheckRegistry.class)
.expect(registry)
.expect(param("name", Optional.of("c")))
.expect(unit -> {
HealthCheckRegistry registry = unit.get(HealthCheckRegistry.class);
expect(registry.runHealthCheck("c")).andReturn(check);
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status(Status.OK)).andReturn(rsp);
expect(rsp.header("Cache-Control", "must-revalidate,no-cache,no-store")).andReturn(rsp);
rsp.send(checks);
})
.run(unit -> {
new HealthCheckHandler().handle(unit.get(Request.class), unit.get(Response.class));
});
}
}