forked from mtusi2026/mtusi2026lab3
Add API integration checks, migration compatibility, rolling restart scenarios and a report verification collector.
89 lines
3.6 KiB
JavaScript
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;
|
|
});
|