cartsnitch/auth/src/__tests__/health.test.ts

import { describe, it } from 'node:test';
import { equal } from 'node:assert';
import http from 'node:http';

describe('Auth health endpoint', () => {
  const startHealthServer = (poolMock) => {
    return new Promise((resolve) => {
      const server = http.createServer(async (req, res) => {
        if (req.url === '/health' && req.method === 'GET') {
          try {
            const client = await poolMock.connect();
            try {
              await Promise.race([
                client.query('SELECT 1'),
                new Promise((_, reject) => setTimeout(() => reject(new Error('DB timeout')), 2000)),
              ]);
            } finally {
              client.release();
            }
            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ status: 'ok', db: 'reachable' }));
          } catch (err) {
            // Mirror src/index.ts: log the error and include the message in the
            // response body so /health 503s are diagnosable from pod logs.
            console.error(
              '[auth /health] DB probe failed:',
              err instanceof Error ? `${err.name}: ${err.message}` : err,
            );
            const detail = err instanceof Error ? err.message : 'unknown error';
            res.writeHead(503, { 'Content-Type': 'application/json' });
            res.end(
              JSON.stringify({ status: 'error', db: 'unreachable', error: detail }),
            );
          }
          return;
        }
        res.writeHead(404);
        res.end();
      });
      server.listen(0, '0.0.0.0', () => {
        const addr = server.address();
        const port = typeof addr === 'object' && addr ? addr.port : 0;
        resolve({ port, close: () => server.close() });
      });
    });
  };

  const makeRequest = (port) => {
    return new Promise((resolve) => {
      const req = http.get(`http://localhost:${port}/health`, (res) => {
        let body = '';
        res.on('data', (chunk) => { body += chunk; });
        res.on('end', () => {
          resolve({ status: res.statusCode, body });
        });
      });
      req.on('error', () => resolve({ status: 0, body: '' }));
    });
  };

  it('returns 200 with db=reachable when pool.connect succeeds', async () => {
    const mockClient = {
      query: async () => ({ rows: [{ 1: 1 }] }),
      release: () => {},
    };
    const poolMock = {
      connect: async () => mockClient,
    };

    const { port, close } = await startHealthServer(poolMock);
    const { status, body } = await makeRequest(port);
    close();

    equal(status, 200);
    equal(body, '{"status":"ok","db":"reachable"}');
  });

  it('returns 503 with db=unreachable when pool.connect throws', async () => {
    const poolMock = {
      connect: async () => { throw new Error('connection refused'); },
    };

    const { port, close } = await startHealthServer(poolMock);
    const { status, body } = await makeRequest(port);
    close();

    equal(status, 503);
    const parsed = JSON.parse(body);
    equal(parsed.status, 'error');
    equal(parsed.db, 'unreachable');
    equal(parsed.error, 'connection refused');
  });

  it('returns 503 with db=unreachable when query times out', async () => {
    const mockClient = {
      query: async () => {
        await new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000));
      },
      release: () => {},
    };
    const poolMock = {
      connect: async () => mockClient,
    };

    const { port, close } = await startHealthServer(poolMock);
    const { status, body } = await makeRequest(port);
    close();

    equal(status, 503);
    const parsed = JSON.parse(body);
    equal(parsed.status, 'error');
    equal(parsed.db, 'unreachable');
    // The query promise rejects with a synthetic 'timeout' error; the
    // Promise.race wrapper also rejects with 'DB timeout'. The body should
    // surface whichever error was thrown — accept either to stay robust.
    equal(typeof parsed.error, 'string');
    equal(parsed.error.length > 0, true);
  });

  it('returns a terminal response for unknown paths (no hang)', async () => {
    const poolMock = { connect: async () => ({ query: async () => {}, release: () => {} }) };
    const { port, close } = await startHealthServer(poolMock);

    const result = await new Promise<{ status: number }>((resolve) => {
      const req = http.get(`http://localhost:${port}/`, (res) => {
        res.resume();
        res.on('end', () => resolve({ status: res.statusCode ?? 0 }));
      });
      req.on('error', () => resolve({ status: 0 }));
      setTimeout(() => resolve({ status: -1 }), 1000);
    });
    close();

    equal(result.status !== -1, true, 'Unknown path must return a terminal response within 1s');
  });
});