@cocreate/socket 0.0.0-stage → 3.0.1

package/src/server/sockets.js

@@ -0,0 +1,149 @@
+/** Map-like views over the Socket Server's existing lifecycle and indexes. */
+class Collection {
+    #source;
+    #value;
+
+    constructor(source, value = value => value) {
+        this.#source = source;
+        this.#value = value;
+    }
+
+    get size() { return this.#source()?.size || 0; }
+    has(id) { return this.#source()?.has(id) || false; }
+    get(id) {
+        const value = this.#source()?.get(id);
+        return value === undefined ? undefined : this.#value(value, id);
+    }
+    *keys() { yield* this.#source()?.keys() || []; }
+    *values() { for (const id of this.keys()) yield this.get(id); }
+    *entries() { for (const id of this.keys()) yield [id, this.get(id)]; }
+    [Symbol.iterator]() { return this.entries(); }
+    forEach(callback, thisArg) {
+        for (const [id, value] of this) callback.call(thisArg, value, id, this);
+    }
+    clear() { for (const id of [...this.keys()]) this.delete(id); }
+}
+
+// Metadata updates preserve references and cannot replace transport or index fields.
+const metadataFields = new WeakMap();
+function update(record, updates, mutable = [], protectedFields = []) {
+    if (!record || !updates || typeof updates !== 'object') return;
+    if (!metadataFields.has(record)) metadataFields.set(record, new Set(mutable));
+    const allowed = metadataFields.get(record);
+    for (const [key, value] of Object.entries(updates)) {
+        if (key.startsWith('_') || key in Object.prototype || protectedFields.includes(key)) continue;
+        if (key in record && !allowed.has(key)) continue;
+        allowed.add(key);
+        Object.defineProperty(record, key, { value, writable: true, enumerable: true, configurable: true });
+    }
+}
+
+class ClientSockets extends Collection {
+    constructor(root, clientId, organizationId) {
+        super(() => organizationId === undefined
+            ? root.manager.clients.get(clientId)
+            : root.manager.organizations.get(organizationId)?.clients.get(clientId));
+        Object.defineProperties(this, {
+            root: { value: root },
+            clientId: { value: clientId },
+            organizationId: { value: organizationId }
+        });
+    }
+    add(socket) {
+        if (socket.clientId !== this.clientId ||
+            (this.organizationId !== undefined && socket.organization_id !== this.organizationId)) {
+            throw new Error('Socket does not belong to this client');
+        }
+        return this.root.add(socket);
+    }
+    set(id, updates) { if (this.has(id)) this.root.set(id, updates); }
+    delete(id) { if (this.has(id)) this.root.delete(id); }
+}
+
+class Clients extends Collection {
+    constructor(root, organizationId) {
+        const views = new WeakMap();
+        super(() => organizationId === undefined ? root.manager.clients
+            : root.manager.organizations.get(organizationId)?.clients,
+        (sockets, id) => {
+            if (!views.has(sockets)) views.set(sockets, new ClientSockets(root, id, organizationId));
+            return views.get(sockets);
+        });
+        Object.defineProperties(this, {
+            root: { value: root },
+            organizationId: { value: organizationId }
+        });
+    }
+    add(socket) {
+        if (this.organizationId !== undefined && socket.organization_id !== this.organizationId) {
+            throw new Error('Socket does not belong to this organization');
+        }
+        this.root.add(socket);
+        return this.get(socket.clientId);
+    }
+    delete(id) { this.get(id)?.clear(); }
+}
+
+class Organizations extends Collection {
+    constructor(root) {
+        const views = new WeakMap();
+        super(() => root.manager.organizations, (organization, id) => {
+            if (!views.has(organization)) {
+                const clients = new Clients(root, id);
+                views.set(organization, new Proxy(organization, {
+                    get(target, key, receiver) {
+                        return key === 'clients' ? clients : Reflect.get(target, key, receiver);
+                    }
+                }));
+            }
+            return views.get(organization);
+        });
+        Object.defineProperty(this, 'root', { value: root });
+    }
+    add(socket) {
+        this.root.add(socket);
+        return this.get(socket.organization_id);
+    }
+    set(id, updates) { update(this.root.manager.organizations.get(id), updates, ['status', 'organizationBalance']); }
+    delete(id) { this.root.manager.destroyOrganizations(id); }
+}
+
+/**
+ * Public socket collection. Add accepts an authenticated socket with id,
+ * clientId and organization_id; delete closes its transport and cleans indexes.
+ * Client and organization add methods accept the same socket and return their record.
+ */
+export default class Sockets extends Collection {
+    constructor(manager) {
+        super(() => manager.sockets);
+        Object.defineProperty(this, 'manager', { value: manager });
+        this.clients = new Clients(this);
+        this.organizations = new Organizations(this);
+    }
+    add(socket) {
+        if (!socket?.id || !socket.clientId || !socket.organization_id) {
+            throw new TypeError('Socket requires id, clientId and organization_id');
+        }
+        const existing = this.get(socket.id);
+        if (existing === socket) return socket;
+        if (existing) throw new Error(`Socket ${socket.id} already exists`);
+        this.manager.onWebSocket(socket);
+        return socket;
+    }
+    set(id, updates) {
+        update(this.get(id), updates, ['clientInfo'], [
+            'id', 'clientId', 'organization_id', 'user_id', 'subscriptionKeys',
+            'bypassDeleteCascade', 'expires', 'isAlive', 'readyState',
+            'host', 'origin', 'pathname', 'socketUrl'
+        ]);
+    }
+    delete(id) {
+        const socket = this.get(id);
+        if (!socket) return;
+        try { socket.close(1000); }
+        finally {
+            if (this.get(id) === socket) this.manager.delete(socket);
+        }
+    }
+    send(data) { return this.manager.send(data); }
+}

package/test/client/transport.test.js

@@ -0,0 +1,84 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { WebSocketServer } from 'ws';
+import { SocketClient } from '../../src/client/index.js';
+
+test('client indexes the same socket by URL and ID and deletes both references', () => {
+    const socket = {
+        id: 'indexed-socket', url: 'ws://localhost/indexed-test', readyState: 1,
+        close() { this.readyState = 3; }
+    };
+    try {
+        SocketClient.set(socket);
+        assert.equal(SocketClient.get(socket.id), socket);
+        assert.equal(SocketClient.get(socket.url), socket);
+        SocketClient.delete(socket.id);
+        assert.equal(socket.readyState, 3);
+        assert.equal(SocketClient.has(socket.id), false);
+        assert.equal(SocketClient.has(socket.url), false);
+    } finally {
+        SocketClient.delete(socket.url);
+    }
+});
+
+for (const denied of [false, true]) {
+    test(`client waits for the ready frame and ${denied ? 'returns the error envelope' : 'resolves its correlated response'}`, { timeout: 5000 }, async t => {
+        await SocketClient.init();
+        if (denied) t.mock.method(console, 'error', () => {});
+        const server = new WebSocketServer({ port: 0, host: '127.0.0.1' });
+        await new Promise(resolve => server.once('listening', resolve));
+        const host = `ws://127.0.0.1:${server.address().port}`;
+        const organization_id = `client-test-${denied}`;
+        const url = `${host}/${organization_id}`;
+        t.after(async () => {
+            const socket = SocketClient.get(url);
+            if (socket) {
+                // Teardown must not start a reconnect cycle after the test.
+                socket.onclose = null;
+                socket.onerror = null;
+                socket.terminate();
+                SocketClient.delete(url);
+            }
+            for (const socket of server.clients) socket.terminate();
+            await new Promise(resolve => server.close(resolve));
+        });
+        const requests = [];
+        let earlyRequests = 0;
+        server.on('connection', socket => {
+            let ready = false;
+            const timer = setTimeout(() => {
+                ready = true;
+                socket.send(JSON.stringify({ method: 'connect', connectedKey: `/${organization_id}` }));
+            }, 30);
+            socket.on('close', () => clearTimeout(timer));
+            socket.on('message', message => {
+                if (!ready) earlyRequests++;
+                const request = JSON.parse(message);
+                requests.push(request);
+                socket.send(JSON.stringify({
+                    ...request, broadcastSender: false,
+                    ...(denied ? { error: 'read denied' } : { object: [{ _id: 'local-test' }] })
+                }));
+            });
+        });
+        const pending = SocketClient.send({
+            method: 'object.read', host, organization_id,
+            array: 'socket_test', broadcast: false
+        });
+        const response = await pending;
+        if (denied) {
+            assert.equal(response.error, 'read denied');
+        } else {
+            assert.deepEqual(response.object, [{ _id: 'local-test' }]);
+        }
+        assert.equal(response.uuid, requests[0].uuid);
+        assert.equal(earlyRequests, 0);
+        assert.equal(requests.length, 1);
+        assert.equal(requests[0].organization_id, organization_id);
+        assert.equal(requests[0].clientId, SocketClient.clientId);
+        assert.equal(requests[0].frameId, SocketClient.frameId);
+        assert.equal(typeof requests[0].uuid, 'string');
+        const socket = SocketClient.get(url);
+        assert.equal(SocketClient.get(socket.id), socket);
+    });
+}

package/test/server/collections.test.js

@@ -0,0 +1,111 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { SocketServer } from '../../src/server/index.js';
+import Sockets from '../../src/server/sockets.js';
+
+function fixture(t) {
+    t.mock.timers.enable({ apis: ['setTimeout'] });
+    const manager = new EventEmitter();
+    Object.setPrototypeOf(manager, SocketServer.prototype);
+    Object.assign(manager, {
+        server: {}, workerId: 1, organizations: new Map(), organizationBalances: new Map(),
+        clients: new Map(), sockets: new Map(), users: new Map()
+    });
+    const sockets = new Sockets(manager);
+    function socket(id, clientId = 'client', organization_id = 'org') {
+        const socket = new EventEmitter();
+        Object.assign(socket, {
+            id, clientId, organization_id, readyState: 1,
+            send() {}, close(code) { this.closeCode = code; this.emit('close'); },
+            terminate() { this.emit('close'); }
+        });
+        return socket;
+    }
+    return { manager, sockets, socket };
+}
+
+test('socket collection shares indexes, protects identity, and preserves metadata references', t => {
+    const f = fixture(t);
+    const socket = f.socket('one');
+    assert.equal(f.sockets.add(socket), socket);
+    assert.equal(f.sockets.add(socket), socket);
+    assert.equal(f.sockets.size, 1);
+    f.sockets.set('one', { label: 'first', id: 'wrong', clientId: 'wrong', user_id: 'wrong', subscriptionKeys: new Set(), close: null });
+    f.sockets.set('one', { label: 'second' });
+    assert.equal(socket.label, 'second');
+    assert.equal(socket.id, 'one');
+    assert.equal(socket.clientId, 'client');
+    assert.equal(socket.user_id, undefined);
+    assert.equal(socket.subscriptionKeys, undefined);
+    assert.equal(typeof socket.close, 'function');
+    assert.equal(f.manager.sockets.get('one'), socket);
+    assert.deepEqual([...f.sockets], [['one', socket]]);
+    assert.equal(f.sockets.clients.get('client').get('one'), socket);
+    assert.equal(f.sockets.organizations.get('org').clients.get('client').get('one'), socket);
+    assert.throws(() => f.sockets.add(f.socket('one')), /already exists/);
+    assert.equal(f.sockets.size, 1);
+});
+
+test('nested client deletion cleans subscriptions without affecting another organization', t => {
+    const f = fixture(t);
+    const first = f.socket('one');
+    const other = f.socket('two', 'client', 'other');
+    f.sockets.clients.add(first);
+    const org = f.sockets.organizations.add(other);
+    f.manager.subscribe(first, 'updates');
+    assert.equal(org, f.sockets.organizations.get('other'));
+    const clients = f.sockets.organizations.get('org').clients;
+    assert.throws(() => clients.add(f.socket('wrong', 'client', 'other')), /does not belong/);
+    clients.delete('client');
+    assert.equal(first.closeCode, 1000);
+    assert.equal(f.sockets.get('one'), undefined);
+    assert.equal(f.sockets.get('two'), other);
+    assert.equal(f.sockets.clients.get('client').size, 1);
+    assert.equal(f.sockets.organizations.get('org').subscriptions.size, 0);
+    t.mock.timers.tick(60000);
+    assert.equal(f.sockets.organizations.has('org'), false);
+    assert.equal(f.sockets.organizations.has('other'), true);
+});
+
+test('organization deletion closes all its sockets and emits one disconnect', t => {
+    const f = fixture(t);
+    const events = [];
+    const listener = id => events.push(id);
+    process.on('orgDisconnected', listener);
+    t.after(() => process.off('orgDisconnected', listener));
+    f.sockets.add(f.socket('one'));
+    f.sockets.add(f.socket('two', 'other-client'));
+    f.sockets.organizations.delete('org');
+    assert.equal(f.sockets.size, 0);
+    assert.equal(f.sockets.clients.size, 0);
+    assert.equal(f.sockets.organizations.size, 0);
+    f.sockets.organizations.delete('org');
+    t.mock.timers.tick(60000);
+    assert.deepEqual(events, ['org']);
+});
+
+test('send delegates to the existing delivery implementation', t => {
+    const f = fixture(t);
+    const payload = { organization_id: 'org', method: 'object.read' };
+    const result = Promise.resolve('sent');
+    t.mock.method(f.manager, 'send', data => { assert.equal(data, payload); return result; });
+    assert.equal(f.sockets.send(payload), result);
+});
+
+test('natural close and reconnect retain one presence transition through the grace period', t => {
+    const f = fixture(t);
+    const events = [];
+    const listener = id => events.push(id);
+    process.on('orgConnected', listener);
+    t.after(() => process.off('orgConnected', listener));
+    const first = f.socket('one');
+    f.sockets.add(first);
+    first.emit('close');
+    assert.equal(f.sockets.size, 0);
+    f.sockets.add(f.socket('two'));
+    t.mock.timers.tick(60000);
+    assert.deepEqual(events, ['org']);
+    assert.equal(f.sockets.organizations.size, 1);
+    assert.equal(f.sockets.organizations.get('org').clients.get('client').size, 1);
+});

package/test/server/send.test.js

@@ -0,0 +1,257 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { SocketServer } from '../../src/server/index.js';
+
+function fixture() {
+    const manager = new EventEmitter();
+    Object.setPrototypeOf(manager, SocketServer.prototype);
+    const attempts = [];
+    const usage = [];
+    const clients = new Map();
+    const subscriptions = new Map([['updates', new Set()]]);
+    manager.organizations = new Map([['org', { clients, subscriptions }]]);
+    manager.sockets = new Map();
+    manager.server = { usage: { send: (data) => usage.push(data) }, send() {} };
+    function socket(id, clientId = 'client', failure) {
+        const socket = {
+            id, clientId, organization_id: 'org', readyState: 1,
+            send(payload, callback) {
+                attempts.push(id);
+                if (failure === 'throw') throw new Error('write failed');
+                setImmediate(() => callback(failure ? new Error('write failed') : undefined));
+            }
+        };
+        if (!clients.has(clientId)) clients.set(clientId, new Map());
+        clients.get(clientId).set(id, socket);
+        manager.sockets.set(id, socket);
+        return socket;
+    }
+    async function send(extra = {}) {
+        let notification;
+        manager.once('notification', (data) => { notification = data; });
+        await manager.send({ method: 'object.read', organization_id: 'org', ...extra });
+        return notification.sent;
+    }
+    return { manager, attempts, usage, clients, subscriptions, socket, send };
+}
+
+test('requesting socket wins over older tabs, with one write per client', async () => {
+    const f = fixture();
+    f.socket('older');
+    const origin = f.socket('origin');
+    f.socket('other', 'other-client');
+    assert.deepEqual(await f.send({ socketId: origin.id, broadcast: true }), ['client', 'other-client']);
+    assert.deepEqual(f.attempts, ['origin', 'other']);
+    assert.equal(f.usage.length, 2);
+});
+
+for (const failure of ['closed', 'callback', 'throw']) {
+    test(`falls back after ${failure} failure and stops after success`, async (t) => {
+        t.mock.method(console, 'error', () => {});
+        const f = fixture();
+        f.socket('fallback');
+        f.socket('unused');
+        const origin = f.socket('origin', 'client', failure);
+        if (failure === 'closed') origin.readyState = 3;
+        assert.deepEqual(await f.send({ socketId: origin.id }), ['client']);
+        assert.deepEqual(f.attempts, failure === 'closed' ? ['fallback'] : ['origin', 'fallback']);
+        assert.equal(f.usage.length, 1);
+    });
+}
+
+test('subscription delivery includes the origin and uses other tabs as fallback', async () => {
+    const f = fixture();
+    f.socket('fallback');
+    const origin = f.socket('origin', 'client', 'callback');
+    f.socket('subscriber', 'other-client');
+    f.socket('unrelated', 'unrelated-client');
+    f.subscriptions.get('updates').add('subscriber');
+    assert.deepEqual(await f.send({ socketId: origin.id, subscriptionKeys: ['updates'] }), ['other-client', 'client']);
+    assert.deepEqual(f.attempts, ['subscriber', 'origin', 'fallback']);
+});
+
+test('subscription ordering cannot select an older tab before the origin', async () => {
+    const f = fixture();
+    f.socket('older');
+    const origin = f.socket('origin');
+    f.subscriptions.get('updates').add('older');
+    f.subscriptions.get('updates').add('origin');
+    await f.send({ socketId: origin.id, subscriptionKeys: ['updates'] });
+    assert.deepEqual(f.attempts, ['origin']);
+});
+
+test('failed writes are not counted as delivery', async () => {
+    const f = fixture();
+    const origin = f.socket('origin', 'client', 'callback');
+    f.socket('fallback', 'client', 'callback');
+    assert.deepEqual(await f.send({ socketId: origin.id }), []);
+    assert.equal(f.usage.length, 0);
+});
+
+test('direct client ID delivery also stops after the first success', async () => {
+    const f = fixture();
+    f.socket('first');
+    f.socket('unused');
+    assert.deepEqual(await f.send({ clientId: 'client' }), ['client']);
+    assert.deepEqual(f.attempts, ['first']);
+});
+
+test('socket payload data is preserved without participating in recipient selection', async () => {
+    const f = fixture();
+    const origin = f.socket('origin', 'client');
+    f.socket('other', 'other-client');
+    let delivered;
+    const write = origin.send;
+    origin.send = (payload, callback) => { delivered = JSON.parse(payload); write(payload, callback); };
+    const socket = { id: 'other', organization_id: 'another-org', purpose: 'application data' };
+    await f.send({ socketId: 'origin', socket });
+    assert.deepEqual(f.attempts, ['origin']);
+    assert.deepEqual(delivered.socket, socket);
+});
+
+for (const lookup of ['no matches', 'no subscriptions', 'no organization', 'unregistered broadcast']) {
+    test(`requester remains a recipient with ${lookup}`, async () => {
+        const f = fixture();
+        const origin = f.socket('origin');
+        const data = { socketId: origin.id, subscriptionKeys: ['missing'] };
+        if (lookup === 'no subscriptions') {
+            delete f.manager.organizations.get('org').subscriptions;
+        } else if (lookup === 'no organization') {
+            f.manager.organizations.clear();
+        } else if (lookup === 'unregistered broadcast') {
+            f.clients.clear();
+            delete data.subscriptionKeys;
+            data.broadcast = true;
+        }
+        assert.deepEqual(await f.send(data), ['client']);
+        assert.deepEqual(f.attempts, ['origin']);
+    });
+}
+
+test('socket send is local-only, resolves undefined, and preserves the routing envelope', async () => {
+    const f = fixture();
+    const socket = f.socket('one');
+    Object.assign(f.manager.server, { id: 'node', workerId: 1, cluster_id: 'local-cluster' });
+    const write = socket.send;
+    socket.send = (payload, callback) => {
+        const message = JSON.parse(payload);
+        for (const field of ['serverId', 'workerId', 'clusterId']) assert.equal(field in message, false);
+        write(payload, callback);
+    };
+    f.manager.server.send = () => assert.fail('Socket transport must never call server.send');
+    const data = { method: 'object.read', organization_id: 'org', clientId: 'client',
+        filter: { query: { _id: { $eq: '$user_id' } } } };
+    assert.equal(await f.manager.send(data), undefined);
+    assert.deepEqual(data.filter.query, { _id: { $eq: '$user_id' } });
+    assert.deepEqual(f.attempts, ['one']);
+});
+
+test('incoming cursor dispatch enters server.send instead of raw socket delivery', async () => {
+    const f = fixture();
+    const socket = f.socket('one');
+    const routed = [];
+    f.manager.server.send = data => routed.push(data);
+    f.manager.send = () => assert.fail('Incoming component messages must enter server.send');
+    const data = { method: 'cursor', organization_id: 'org' };
+    await f.manager.Message(socket, data);
+    assert.deepEqual(routed, [data]);
+});
+
+test('incoming messages replace client-supplied identity with accepted socket values', async () => {
+    const f = fixture();
+    const socket = f.socket('trusted-socket', 'trusted-client');
+    Object.assign(socket, { user_id: 'trusted-user', host: 'trusted.example' });
+    const received = [];
+    f.manager.authorize = {
+        check: async (data, userId) => {
+            received.push({ data, userId });
+            return true;
+        }
+    };
+    f.manager.on('api', data => received.push({ routed: data }));
+    const data = {
+        api: 'example',
+        user_id: 'forged-user',
+        socketId: 'forged-socket',
+        clientId: 'forged-client',
+        organization_id: 'forged-org',
+        host: 'forged.example',
+        socket: { user_id: 'forged-socket-user', id: 'forged-socket' },
+        replyOrganizationId: 'forged-org'
+    };
+
+    await f.manager.Message(socket, data);
+
+    assert.equal(received[0].userId, 'trusted-user');
+    assert.equal(received[0].data.user_id, 'trusted-user');
+    assert.equal(received[0].data.socketId, 'trusted-socket');
+    assert.equal(received[0].data.clientId, 'trusted-client');
+    assert.equal(received[0].data.organization_id, 'org');
+    assert.equal(received[0].data.replyOrganizationId, 'org');
+    assert.equal(received[0].data.host, 'trusted.example');
+    assert.deepEqual(received[0].data.socket, { user_id: 'forged-socket-user', id: 'forged-socket' });
+    assert.equal(received[1].routed, data);
+    assert.equal(received[1].routed.socket, data.socket);
+});
+
+test('incoming unauthenticated messages cannot retain a supplied user ID', async () => {
+    const f = fixture();
+    const socket = f.socket('anonymous-socket', 'anonymous-client');
+    const received = [];
+    f.manager.authorize = {
+        check: async (data, userId) => {
+            received.push({ data, userId });
+            return true;
+        }
+    };
+    f.manager.on('api', data => received.push({ routed: data }));
+    const data = { api: 'example', user_id: 'forged-user' };
+
+    await f.manager.Message(socket, data);
+
+    assert.equal(received[0].userId, undefined);
+    assert.equal('user_id' in received[0].data, false);
+    assert.equal(received[0].data.socketId, 'anonymous-socket');
+    assert.equal(received[0].data.clientId, 'anonymous-client');
+    assert.equal(received[0].data.organization_id, 'org');
+});
+
+test('activity records terminate their own logging flow', async () => {
+    const f = fixture();
+    const activities = [];
+    const pending = [];
+    f.manager.on('object.create', request => {
+        activities.push(request);
+        // Bound a regression instead of allowing it to recurse indefinitely.
+        if (activities.length < 3) pending.push(f.manager.send({ ...request, object: [{ _id: 'activity' }] }));
+    });
+    await f.manager.send({ method: 'object.create', array: 'users', organization_id: 'org', object: [{ _id: 'user' }] });
+    await Promise.all(pending);
+    assert.equal(activities.length, 1);
+    assert.equal(activities[0].log, false);
+    await f.manager.send({ method: 'object.create', array: 'activities', organization_id: 'org', object: [{ _id: 'manual-activity' }] });
+    assert.equal(activities.length, 1, 'Activity writes do not generate more activity writes');
+});
+
+test('storage authorization fallback preserves the trusted tenant reply scope', async () => {
+    const f = fixture();
+    const socket = f.socket('socket');
+    f.manager.authorize = { check: async data => data.organization_id === 'org' ? { serverStorage: false } : true };
+    let received;
+    f.manager.on('object.read', data => { received = data; });
+    const previous = process.env.organization_id;
+    process.env.organization_id = 'platform';
+    try {
+        await f.manager.Message(socket, {
+            method: 'object.read', array: 'files', replyOrganizationId: 'forged-org'
+        });
+        assert.equal(received.organization_id, 'platform');
+        assert.equal(received.database, 'platform');
+        assert.equal(received.replyOrganizationId, 'org');
+        assert.equal(received.socketId, 'socket');
+    } finally {
+        if (previous === undefined) delete process.env.organization_id;
+        else process.env.organization_id = previous;
+    }
+});