Testing System Health Check Endpoints

In this lesson, you will learn how to design and test robust health check endpoints to ensure your load balancer routes traffic only to fully operational Node.js instances.

Why Health Checks Matter for Traffic Management

In a distributed environment, a load balancer (like Nginx, AWS ALB, or a Kubernetes Ingress) relies on your /health endpoint to decide whether to send incoming requests to your process. If your endpoint returns a 200 OK while the service is experiencing high latency or lost database connectivity, the load balancer will continue routing traffic to a "zombie" instance, resulting in failed user requests.

To test this effectively, we must move beyond a simple static response and implement "Deep Health Checks."

Testing Deep Health Dependencies

A robust health check should not just return a success message; it must verify that critical external dependencies are functional. When testing this, you are validating that the health probe accurately reflects the state of the system's "vital organs."

Consider this Express-based implementation:

app.get('/health', async (req, res) => {
  try {
    // Check database connectivity
    await db.query('SELECT 1');
    // Check if the service is not currently shutting down (graceful degradation)
    if (isShuttingDown) return res.status(503).send('Service shutting down');
    
    res.status(200).send('OK');
  } catch (err) {
    res.status(503).send('Service Unavailable');
  }
});

Testing Strategy

When writing automated tests for this endpoint, use a tool like supertest to verify specific failure modes:

1. Dependency Failure: Mock the database driver to throw an error and assert that the endpoint returns a 503 Service Unavailable.
2. State-based Failure: Simulate a high-load scenario (via a mocked resource monitor) to ensure the endpoint returns a 503 if the instance is past its resource threshold.
3. Load Balancer Logic: Assert that the response headers are not cached. If a load balancer receives a cached 200 OK from a previous check, it might keep sending traffic to a failed instance. Use Cache-Control: no-cache to ensure every health probe hits the actual code path.

By verifying that the endpoint reflects real-time connectivity and resource availability, you prevent the load balancer from overwhelming a struggling process.

Key Takeaway: Health check endpoints must perform deep validation of dependencies and state to ensure load balancers can accurately determine if an instance is capable of handling production traffic.