Imports the previously untracked working tree as-is so that the review changes that follow (requirements -> design -> implementation) can be reviewed as diffs and reverted if needed. No content changes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
99 lines
9.5 KiB
JavaScript
99 lines
9.5 KiB
JavaScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import http from 'node:http';
|
|
import { randomUUID, webcrypto } from 'node:crypto';
|
|
import { execFile } from 'node:child_process';
|
|
import { promisify } from 'node:util';
|
|
import { createRequire } from 'node:module';
|
|
import { pathToFileURL } from 'node:url';
|
|
import { createGateway } from '../../gateway/server.mjs';
|
|
import factory from '../client-factory.cjs';
|
|
const require = createRequire(new URL('../../package.json', import.meta.url));
|
|
const protocol = await import(pathToFileURL(require.resolve('open-collaboration-protocol')).href);
|
|
const { io } = await import(pathToFileURL(require.resolve('socket.io-client')).href);
|
|
const { OpenCollaborationYjsProvider } = await import(pathToFileURL(require.resolve('open-collaboration-yjs')).href);
|
|
const Y = await import('../../node_modules/yjs/dist/yjs.mjs');
|
|
const { Awareness } = await import('../../node_modules/y-protocols/awareness.js');
|
|
protocol.initializeProtocol({ cryptoModule: webcrypto });
|
|
const execute = promisify(execFile);
|
|
const docker = (...args) => execute('docker', ['--context', process.env.WF_TEST_DOCKER_CONTEXT ?? 'colima', ...args], { timeout: 30_000 });
|
|
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
|
|
async function until(check, message) { const end = Date.now() + 10_000; do { if (await check()) return; await sleep(25); } while (Date.now() < end); throw new Error(message); }
|
|
async function listen(server) { await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); return `http://127.0.0.1:${server.address().port}`; }
|
|
|
|
test('two isolated OCT instances support scoped Socket.IO/Yjs collaboration and reject invite/token reuse across workspaces', { skip: process.env.WF_OCT_INTEGRATION !== '1', timeout: 60_000 }, async () => {
|
|
const names = [], connections = [], docs = [], awareness = [], sockets = [];
|
|
let api, gateway; const revoked = new Set();
|
|
const members = { alice: { workspace: 'workspace-a', role: 'developer' }, bob: { workspace: 'workspace-a', role: 'developer' }, charlie: { workspace: 'workspace-b', role: 'developer' }, viewer: { workspace: 'workspace-a', role: 'viewer' } };
|
|
try {
|
|
const origins = {};
|
|
for (const workspace of ['workspace-a', 'workspace-b']) {
|
|
const name = `wishforge-oct-test-${randomUUID().slice(0, 8)}`; names.push(name);
|
|
await docker('run', '-d', '--rm', '--name', name, '--read-only', '--cap-drop', 'ALL', '--security-opt', 'no-new-privileges', '--tmpfs', '/tmp:rw,noexec,nosuid,size=16m', '-p', '127.0.0.1::8100', '-e', `WF_WORKSPACE_ID=${workspace}`, '-e', 'WF_TENANT_ID=fixture-tenant', '-e', 'WISHFORGE_GATEWAY_ENFORCED=true', 'wishforge/oct-workspace:0.3.1-wf1');
|
|
const port = (await docker('port', name, '8100/tcp')).stdout.trim().split(':').at(-1); origins[workspace] = `http://127.0.0.1:${port}`;
|
|
await until(async () => { try { return (await fetch(`${origins[workspace]}/api/meta`)).ok; } catch { return false; } }, 'OCT did not start');
|
|
}
|
|
api = http.createServer(async (req, res) => {
|
|
let text = ''; for await (const bytes of req) text += bytes;
|
|
const request = JSON.parse(text), who = members[request.userToken], workspace = req.url.split('/')[3];
|
|
if (!who || revoked.has(request.userToken) || who.workspace !== workspace) { res.writeHead(403); res.end(); return; }
|
|
assert.equal(request.operation, 'edit');
|
|
res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ data: { tenantId: 'fixture-tenant', projectId: `project-${workspace}`, workspaceId: workspace, role: who.role, upstreamUrl: origins[workspace], collaborationUpstreamUrl: origins[workspace] } }));
|
|
});
|
|
const apiOrigin = await listen(api);
|
|
// Reserve a local port before gateway construction, which requires its public origin.
|
|
const reserve = http.createServer(); const publicUrl = await listen(reserve); await new Promise(resolve => reserve.close(resolve));
|
|
gateway = createGateway({ publicUrl, tenantId: 'fixture-tenant', serviceToken: 'gateway-fixture-token', apiOrigin, allowedUpstreamOrigins: Object.values(origins), allowedCollaborationOrigins: Object.values(origins), reauthorizeMs: 50 });
|
|
await new Promise(resolve => gateway.server.listen(Number(new URL(publicUrl).port), '127.0.0.1', resolve));
|
|
async function session(user) {
|
|
const workspace = members[user].workspace;
|
|
const launch = await fetch(`${publicUrl}/launch`, { method: 'POST', headers: { authorization: `Bearer ${user}`, 'content-type': 'application/json' }, body: JSON.stringify({ workspaceId: workspace }) });
|
|
if (!launch.ok) return { status: launch.status };
|
|
const { launchUrl } = await launch.json(); const response = await fetch(launchUrl, { redirect: 'manual' });
|
|
return { status: response.status, cookie: response.headers.get('set-cookie').split(';')[0], workspace };
|
|
}
|
|
const alice = await session('alice'), bob = await session('bob'), charlie = await session('charlie');
|
|
assert.equal((await session('viewer')).status, 403);
|
|
function client(user, displayName) {
|
|
const url = `${publicUrl}/workspaces/${user.workspace}/collaboration/`;
|
|
const localFetch = (target, init = {}) => fetch(target, { ...init, headers: { ...init.headers, cookie: user.cookie, origin: publicUrl } });
|
|
return factory.createPrefixConnectionProvider({ ...protocol, io: (origin, options) => { const socket = io(origin, { ...options, withCredentials: false, extraHeaders: { ...options.extraHeaders, Cookie: user.cookie, Origin: publicUrl } }); sockets.push(socket); socket.on('connect_error', error => console.error('OCT socket connection error:', error.message, error.description, error.context?.status, error.context?.responseText?.slice(0,300))); return socket; } }, { url, browserLocation: `${publicUrl}/workspaces/${user.workspace}/`, client: 'WishForge integration', fetch: localFetch, authenticationHandler: async (token, metadata) => {
|
|
assert.equal(metadata.providers[0].endpoint, 'api/login/simple');
|
|
return (await localFetch(new URL(metadata.providers[0].endpoint, url), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ token, user: displayName }) })).ok;
|
|
} });
|
|
}
|
|
const hostProvider = client(alice, 'Host display name'), guestProvider = client(bob, 'Guest display name');
|
|
const claim = await hostProvider.createRoom({ abortSignal: AbortSignal.timeout(10_000) });
|
|
const host = await hostProvider.connect(claim.roomToken); connections.push(host);
|
|
let hostIdentity; host.peer.onInfo((_origin, peer) => { hostIdentity = peer; });
|
|
host.peer.onJoinRequest(async () => ({ workspace: { name: 'fixture', folders: ['source'] } }));
|
|
host.room.onJoin((_origin, peer) => host.peer.init(peer.id, { protocol: protocol.VERSION, host: hostIdentity, guests: [peer], permissions: { readonly: false }, capabilities: {}, workspace: { name: 'fixture', folders: ['source'] } }));
|
|
await until(() => !!hostIdentity, 'Host peer did not connect');
|
|
const guestClaim = await guestProvider.joinRoom({ roomId: claim.roomId, abortSignal: AbortSignal.timeout(10_000) });
|
|
const guest = await guestProvider.connect(guestClaim.roomToken, guestClaim.host); connections.push(guest); guest.peer.onInfo(() => {});
|
|
let initialized = false; guest.peer.onInit(() => { initialized = true; });
|
|
await until(() => initialized, 'Guest did not receive encrypted initialization');
|
|
for (const connection of [host, guest]) { const doc = new Y.Doc(); const state = new Awareness(doc); docs.push(doc); awareness.push(state); const provider = new OpenCollaborationYjsProvider(connection, doc, state); provider.connect(); }
|
|
docs[0].getText('source/example.ts').insert(0, 'const greeting = "hello";');
|
|
await until(() => docs[1].getText('source/example.ts').toString().includes('hello'), 'Host edit did not reach guest');
|
|
docs[1].getText('source/example.ts').insert(docs[1].getText('source/example.ts').length, '\n// guest edit');
|
|
await until(() => docs[0].getText('source/example.ts').toString().includes('guest edit'), 'Guest edit did not reach host');
|
|
assert.equal(docs[0].getText('source/example.ts').toString(), docs[1].getText('source/example.ts').toString());
|
|
assert.equal((await fetch(`${publicUrl}/workspaces/workspace-a/collaboration/api/meta`, { headers: { cookie: charlie.cookie } })).status, 401);
|
|
const outsider = client(charlie, 'Allowed in other workspace');
|
|
await assert.rejects(() => outsider.joinRoom({ roomId: claim.roomId, abortSignal: AbortSignal.timeout(5_000) }), /Room not found/);
|
|
const tokenCheck = await fetch(`${origins['workspace-b']}/api/login/validate`, { method: 'POST', headers: { 'x-oct-jwt': hostProvider.authToken } });
|
|
assert.equal((await tokenCheck.json()).valid, false, 'Per-instance keys must reject another workspace OCT JWT');
|
|
revoked.add('bob');
|
|
await until(() => sockets[1].disconnected, 'Revoked member websocket was not closed');
|
|
assert.equal((await fetch(`${publicUrl}/workspaces/workspace-a/collaboration/api/meta`, { headers: { cookie: bob.cookie } })).status, 403);
|
|
} catch (error) {
|
|
for (const name of names) console.error((await docker('logs', '--tail', '15', name)).stdout);
|
|
throw error;
|
|
} finally {
|
|
for (const state of awareness) state.destroy(); for (const doc of docs) doc.destroy(); for (const connection of connections) connection.dispose(); for (const socket of sockets) socket.disconnect();
|
|
if (gateway) await gateway.close(); if (api) await new Promise(resolve => api.close(resolve));
|
|
await Promise.all(names.map(name => docker('stop', '-t', '1', name).catch(() => undefined)));
|
|
}
|
|
});
|