Files
mtusi2026lab3/test/draining.mjs
T
qrtx 5c8bcf0f80 test: cover persistence failover and graceful draining
Add API integration checks, migration compatibility, rolling restart scenarios and a report verification collector.
2026-10-29 11:47:46 +03:00

89 lines
3.6 KiB
JavaScript

import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import { setImmediate, setTimeout } from 'node:timers/promises';
import test from 'node:test';
const require = createRequire(import.meta.url);
const { Module } = require('@nestjs/common');
const { NestFactory } = require('@nestjs/core');
const { AppController } = require('../dist/app.controller');
const { AppService } = require('../dist/app.service');
const { PrismaService } = require('../dist/prisma/prisma.service');
const { createFastifyAdapter } = require('../dist/common/http/fastify-adapter');
async function fixture(t, query = async () => []) {
const state = { queries: 0, destroyed: false };
const database = {
async $queryRaw() {
state.queries += 1;
return query();
},
onModuleDestroy() {
state.destroyed = true;
},
};
class FixtureModule {}
Module({
controllers: [AppController],
providers: [AppService, { provide: PrismaService, useValue: database }],
})(FixtureModule);
const adapter = createFastifyAdapter(30);
const app = await NestFactory.create(FixtureModule, adapter, { logger: false });
t.after(async () => {
state.release?.();
await app.close();
});
return { app, adapter, state, controller: app.get(AppController) };
}
test('draining keeps liveness and dependencies alive until active HTTP work completes', { timeout: 30000 }, async (t) => {
const { app, adapter, state, controller } = await fixture(t);
const entered = Promise.withResolvers();
const release = Promise.withResolvers();
// Always release the request, including when an assertion fails.
state.release = () => release.resolve();
adapter.getInstance().get('/slow-work', async () => {
entered.resolve();
await release.promise;
assert.equal(state.destroyed, false, 'database was destroyed during active work');
return { completed: true };
});
await app.listen(0, '127.0.0.1');
t.diagnostic('HTTP listener started');
const { port } = app.getHttpServer().address();
await controller.ready();
const response = fetch(`http://127.0.0.1:${port}/slow-work`, { signal: AbortSignal.timeout(5000) });
await entered.promise;
t.diagnostic('Slow request started');
let closed = false;
const closing = app.close('SIGTERM').then(() => { closed = true; });
await setImmediate();
assert.equal(adapter.isDraining, true);
assert.equal(adapter.beforeClose(), adapter.beforeClose(), 'shutdown must be idempotent');
await assert.rejects(controller.ready(), (error) => error.getStatus() === 503);
assert.equal(state.queries, 1, 'draining readiness must not acquire a DB connection');
assert.deepEqual(controller.live(), { status: 'ok' });
await setTimeout(80);
assert.equal(closed, false, 'server closed before the active request completed');
assert.equal(state.destroyed, false, 'dependencies closed before the active request');
release.resolve();
t.diagnostic('Slow request released');
assert.deepEqual(await (await response).json(), { completed: true });
await closing;
t.diagnostic('Application shutdown completed');
assert.equal(state.destroyed, true);
});
test('readiness already querying the DB cannot return 200 after draining begins', { timeout: 10000 }, async (t) => {
const query = Promise.withResolvers();
const { app, adapter, controller } = await fixture(t, () => query.promise);
await app.init();
const pending = assert.rejects(controller.ready(), (error) => error.getStatus() === 503);
const closing = app.close('SIGTERM');
await setImmediate();
assert.equal(adapter.isDraining, true);
query.resolve([]);
await pending;
await closing;
});