feat(ql3): establish 3.0 incubation baseline

test/back/headlessWorkerRuntime.test.cjs

@@ -0,0 +1,138 @@
+require('ts-node/register/transpile-only');
+
+const assert = require('node:assert/strict');
+const { test } = require('node:test');
+const {
+  bootstrapHeadlessWorkerRuntime,
+} = require('../../back/runtime/application/headlessWorkerRuntime');
+
+function heartbeat(calls, overrides = {}) {
+  return {
+    currentSession() {
+      return undefined;
+    },
+    async start() {
+      calls.push('heartbeat.start');
+      return true;
+    },
+    async drain() {
+      calls.push('heartbeat.drain');
+      return undefined;
+    },
+    async stop() {
+      calls.push('heartbeat.stop');
+      return 'drained';
+    },
+    ...overrides,
+  };
+}
+
+test('is default-off without touching Worker dependencies', async () => {
+  const calls = [];
+  const result = await bootstrapHeadlessWorkerRuntime({
+    profile: 'worker',
+    heartbeat: heartbeat(calls),
+    executions: {
+      async drain() {
+        calls.push('executions.drain');
+        return 'drained';
+      },
+    },
+  });
+  assert.deepEqual(result, { status: 'disabled' });
+  assert.deepEqual(calls, []);
+});
+
+test('refuses to graft the headless topology onto a control-plane profile', async () => {
+  const calls = [];
+  await assert.rejects(
+    bootstrapHeadlessWorkerRuntime({
+      enabled: true,
+      profile: 'cluster-control',
+      heartbeat: heartbeat(calls),
+      executions: {
+        async drain() {
+          return 'drained';
+        },
+      },
+    }),
+    /cannot activate the headless Worker runtime/,
+  );
+  assert.deepEqual(calls, []);
+});
+
+test('advertises drain before waiting for tasks and disconnecting', async () => {
+  const calls = [];
+  const result = await bootstrapHeadlessWorkerRuntime({
+    enabled: true,
+    profile: 'worker',
+    heartbeat: heartbeat(calls),
+    executions: {
+      async drain() {
+        calls.push('executions.drain');
+        return 'drained';
+      },
+    },
+  });
+  assert.equal(result.status, 'active');
+  assert.equal(await result.runtime.drainAndStop(), 'stopped');
+  assert.deepEqual(calls, [
+    'heartbeat.start',
+    'heartbeat.drain',
+    'executions.drain',
+    'heartbeat.stop',
+  ]);
+});
+
+test('keeps a draining session alive when task shutdown reaches its bound', async () => {
+  const calls = [];
+  const result = await bootstrapHeadlessWorkerRuntime({
+    enabled: true,
+    profile: 'worker',
+    heartbeat: heartbeat(calls),
+    executions: {
+      async drain() {
+        calls.push('executions.drain');
+        return 'timed_out';
+      },
+    },
+  });
+  assert.equal(result.status, 'active');
+  assert.equal(await result.runtime.drainAndStop(), 'executions_timed_out');
+  assert.deepEqual(calls, [
+    'heartbeat.start',
+    'heartbeat.drain',
+    'executions.drain',
+  ]);
+});
+
+test('reports a control-plane disconnect failure without claiming shutdown', async () => {
+  const calls = [];
+  const result = await bootstrapHeadlessWorkerRuntime({
+    enabled: true,
+    profile: 'worker',
+    heartbeat: heartbeat(calls, {
+      async stop() {
+        calls.push('heartbeat.stop');
+        return 'disconnect_failed';
+      },
+    }),
+    executions: {
+      async drain() {
+        calls.push('executions.drain');
+        return 'drained';
+      },
+    },
+  });
+  assert.equal(result.status, 'active');
+  assert.equal(
+    await result.runtime.drainAndStop(),
+    'heartbeat_disconnect_failed',
+  );
+  assert.deepEqual(calls, [
+    'heartbeat.start',
+    'heartbeat.drain',
+    'executions.drain',
+    'heartbeat.stop',
+  ]);
+});