feat(ql3): establish 3.0 incubation baseline

2026-09-23 03:18:09 +08:00 · 2026-08-12 00:25:26 +08:00
parent 4bf92dcfeb
commit c699c32461
2817 changed files with 779642 additions and 653 deletions
@@ -0,0 +1,150 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const { PassThrough } = require('node:stream');
+const { test } = require('node:test');
+const {
+  WorkerRemoteOfferHttpsTransport,
+} = require('../dist/remote-execution/remoteOfferDeliveryEntrypoint');
+
+const AUTHORIZATION =
+  `Worker ql3w_worker_primary_${Buffer.alloc(32, 7).toString('base64url')}`;
+const PATH =
+  '/api/v3/worker-ingress/workers/edge-1/sessions/018f0000-0000-7000-8000-000000000001/offers';
+
+function requestFactory(responseFactory, observations) {
+  return (options, callback) => {
+    observations.options = options;
+    const request = new EventEmitter();
+    request.setTimeout = (timeout, handler) => {
+      observations.timeout = timeout;
+      observations.timeoutHandler = handler;
+      return request;
+    };
+    request.destroy = (error) => {
+      if (error) queueMicrotask(() => request.emit('error', error));
+    };
+    request.end = (body) => {
+      observations.body = Buffer.from(body);
+      const response = responseFactory();
+      queueMicrotask(() => callback(response));
+    };
+    return request;
+  };
+}
+
+function response(body, headers = {}) {
+  const stream = new PassThrough();
+  stream.statusCode = 200;
+  stream.headers = {
+    'content-type': 'application/json',
+    'content-length': String(Buffer.byteLength(body)),
+    ...headers,
+  };
+  queueMicrotask(() => stream.end(body));
+  return stream;
+}
+
+function credentials() {
+  return {
+    authorization: AUTHORIZATION,
+    certificateChainPem: 'client certificate',
+    privateKeyPem: 'client private key',
+    trustAnchors: ['trusted ca'],
+  };
+}
+
+function request() {
+  return {
+    path: PATH,
+    body: {
+      workerGeneration: 2,
+      offerId: 'offer-1',
+      leaseToken: 'worker_generated_lease_capability_0000000000000001',
+    },
+    maximumResponseBytes: 1024,
+  };
+}
+
+test('uses one bounded TLS 1.3 mTLS POST with the Worker credential', async () => {
+  const observations = {};
+  const transport = new WorkerRemoteOfferHttpsTransport({
+    origin: 'https://cluster.example:7443',
+    credentials: { async load() { return credentials(); } },
+    requestTimeoutMs: 5_000,
+    requestFactory: requestFactory(
+      () => response('{"status":"idle"}'),
+      observations,
+    ),
+  });
+  try {
+    const result = await transport.exchange(request());
+    assert.equal(Buffer.from(result).toString('utf8'), '{"status":"idle"}');
+    assert.equal(observations.options.protocol, 'https:');
+    assert.equal(observations.options.hostname, 'cluster.example');
+    assert.equal(observations.options.port, '7443');
+    assert.equal(observations.options.minVersion, 'TLSv1.3');
+    assert.equal(observations.options.rejectUnauthorized, true);
+    assert.equal(observations.options.headers.authorization, AUTHORIZATION);
+    assert.equal(observations.options.path, PATH);
+    assert.equal(observations.timeout, 5_000);
+    assert.deepEqual(JSON.parse(observations.body.toString('utf8')), request().body);
+  } finally {
+    transport.close();
+  }
+});
+
+test('rejects plaintext origins, malformed credentials and oversized responses', async () => {
+  assert.throws(
+    () => new WorkerRemoteOfferHttpsTransport({
+      origin: 'http://cluster.example',
+      credentials: { async load() { return credentials(); } },
+    }),
+    /invalid_configuration/,
+  );
+
+  const malformed = new WorkerRemoteOfferHttpsTransport({
+    origin: 'https://cluster.example',
+    credentials: {
+      async load() { return { ...credentials(), authorization: 'Bearer token' }; },
+    },
+    requestFactory: requestFactory(
+      () => response('{}'),
+      {},
+    ),
+  });
+  await assert.rejects(malformed.exchange(request()), /credentials_unavailable/);
+  malformed.close();
+
+  const observations = {};
+  const oversized = new WorkerRemoteOfferHttpsTransport({
+    origin: 'https://cluster.example',
+    credentials: { async load() { return credentials(); } },
+    requestFactory: requestFactory(() => {
+      const stream = new PassThrough();
+      stream.statusCode = 200;
+      stream.headers = { 'content-type': 'application/json' };
+      queueMicrotask(() => stream.end(Buffer.alloc(1025, 1)));
+      return stream;
+    }, observations),
+  });
+  await assert.rejects(oversized.exchange(request()), /response_too_large/);
+  oversized.close();
+});
+
+test('propagates caller cancellation and refuses work after close', async () => {
+  const transport = new WorkerRemoteOfferHttpsTransport({
+    origin: 'https://cluster.example',
+    credentials: { async load() { return credentials(); } },
+    requestFactory: requestFactory(() => response('{}'), {}),
+  });
+  const controller = new AbortController();
+  controller.abort(new Error('shutdown'));
+  await assert.rejects(
+    transport.exchange({ ...request(), signal: controller.signal }),
+    /shutdown/,
+  );
+  transport.close();
+  await assert.rejects(transport.exchange(request()), /closed/);
+});