Source code
Revision control
Copy as Markdown
Other Tools
/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^ws$" }] */
'use strict';
const assert = require('assert');
const crypto = require('crypto');
const https = require('https');
const http = require('http');
const path = require('path');
const net = require('net');
const tls = require('tls');
const os = require('os');
const fs = require('fs');
const { URL } = require('url');
const Sender = require('../lib/sender');
const WebSocket = require('..');
const {
CloseEvent,
ErrorEvent,
Event,
MessageEvent
} = require('../lib/event-target');
const { EMPTY_BUFFER, GUID, kListener, NOOP } = require('../lib/constants');
class CustomAgent extends http.Agent {
addRequest() {}
}
describe('WebSocket', () => {
describe('#ctor', () => {
it('throws an error when using an invalid url', () => {
assert.throws(
() => new WebSocket('foo'),
/^SyntaxError: Invalid URL: foo$/
);
assert.throws(
/^SyntaxError: The URL's protocol must be one of "ws:", "wss:", or "ws\+unix:"$/
);
assert.throws(
() => new WebSocket('ws+unix:'),
/^SyntaxError: The URL's pathname is empty$/
);
assert.throws(
/^SyntaxError: The URL contains a fragment identifier$/
);
});
it('throws an error if a subprotocol is invalid or duplicated', () => {
for (const subprotocol of [null, '', 'a,b', ['a', 'a']]) {
assert.throws(
/^SyntaxError: An invalid or duplicated subprotocol was specified$/
);
}
});
it('accepts `url.URL` objects as url', (done) => {
const agent = new CustomAgent();
agent.addRequest = (req, opts) => {
assert.strictEqual(opts.host, '::1');
assert.strictEqual(req.path, '/');
done();
};
});
describe('options', () => {
it('accepts the `options` object as 3rd argument', () => {
const agent = new CustomAgent();
let count = 0;
let ws;
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('sec-websocket-protocol'),
undefined
);
count++;
};
assert.strictEqual(count, 2);
});
it('accepts the `maxPayload` option', (done) => {
const maxPayload = 20480;
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
perMessageDeflate: true,
maxPayload
});
ws.on('open', () => {
assert.strictEqual(ws._receiver._maxPayload, maxPayload);
assert.strictEqual(
ws._receiver._extensions['permessage-deflate']._maxPayload,
maxPayload
);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
ws.close();
});
});
it('throws an error when using an invalid `protocolVersion`', () => {
const options = { agent: new CustomAgent(), protocolVersion: 1000 };
assert.throws(
/^RangeError: Unsupported protocol version: 1000 \(supported versions: 8, 13\)$/
);
});
it('honors the `generateMask` option', (done) => {
const data = Buffer.from('foo');
const wss = new WebSocket.Server({ port: 0 }, () => {
generateMask() {}
});
ws.on('open', () => {
ws.send(data);
});
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1005);
assert.deepStrictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
});
wss.on('connection', (ws) => {
const chunks = [];
ws._socket.prependListener('data', (chunk) => {
chunks.push(chunk);
});
ws.on('message', (message) => {
assert.deepStrictEqual(message, data);
assert.deepStrictEqual(
Buffer.concat(chunks).slice(2, 6),
Buffer.alloc(4)
);
ws.close();
});
});
});
});
});
describe('Constants', () => {
const readyStates = {
CONNECTING: 0,
OPEN: 1,
CLOSING: 2,
CLOSED: 3
};
Object.keys(readyStates).forEach((state) => {
describe(`\`${state}\``, () => {
it('is enumerable property of class', () => {
const descriptor = Object.getOwnPropertyDescriptor(WebSocket, state);
assert.deepStrictEqual(descriptor, {
configurable: false,
enumerable: true,
value: readyStates[state],
writable: false
});
});
it('is enumerable property of prototype', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
state
);
assert.deepStrictEqual(descriptor, {
configurable: false,
enumerable: true,
value: readyStates[state],
writable: false
});
});
});
});
});
describe('Attributes', () => {
describe('`binaryType`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'binaryType'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set !== undefined);
});
it("defaults to 'nodebuffer'", () => {
agent: new CustomAgent()
});
assert.strictEqual(ws.binaryType, 'nodebuffer');
});
it("can be changed to 'arraybuffer' or 'fragments'", () => {
agent: new CustomAgent()
});
ws.binaryType = 'arraybuffer';
assert.strictEqual(ws.binaryType, 'arraybuffer');
ws.binaryType = 'foo';
assert.strictEqual(ws.binaryType, 'arraybuffer');
ws.binaryType = 'fragments';
assert.strictEqual(ws.binaryType, 'fragments');
ws.binaryType = '';
assert.strictEqual(ws.binaryType, 'fragments');
ws.binaryType = 'nodebuffer';
assert.strictEqual(ws.binaryType, 'nodebuffer');
});
});
describe('`bufferedAmount`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'bufferedAmount'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set === undefined);
});
it('defaults to zero', () => {
agent: new CustomAgent()
});
assert.strictEqual(ws.bufferedAmount, 0);
});
it('defaults to zero upon "open"', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.onopen = () => {
assert.strictEqual(ws.bufferedAmount, 0);
wss.close(done);
};
});
wss.on('connection', (ws) => {
ws.close();
});
});
it('takes into account the data in the sender queue', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws.send('foo');
assert.strictEqual(ws.bufferedAmount, 3);
ws.send('bar', (err) => {
assert.ifError(err);
assert.strictEqual(ws.bufferedAmount, 0);
wss.close(done);
});
assert.strictEqual(ws.bufferedAmount, 6);
});
}
);
wss.on('connection', (ws) => {
ws.close();
});
});
it('takes into account the data in the socket queue', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
const data = Buffer.alloc(1024, 61);
while (ws.bufferedAmount === 0) {
ws.send(data);
}
assert.ok(ws.bufferedAmount > 0);
assert.strictEqual(
ws.bufferedAmount,
ws._socket._writableState.length
);
ws.on('close', () => wss.close(done));
ws.close();
});
});
});
describe('`extensions`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'bufferedAmount'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set === undefined);
});
it('exposes the negotiated extensions names (1/2)', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
assert.strictEqual(ws.extensions, '');
ws.on('open', () => {
assert.strictEqual(ws.extensions, '');
ws.on('close', () => wss.close(done));
});
});
wss.on('connection', (ws) => {
assert.strictEqual(ws.extensions, '');
ws.close();
});
});
it('exposes the negotiated extensions names (2/2)', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
assert.strictEqual(ws.extensions, '');
ws.on('open', () => {
assert.strictEqual(ws.extensions, 'permessage-deflate');
ws.on('close', () => wss.close(done));
});
}
);
wss.on('connection', (ws) => {
assert.strictEqual(ws.extensions, 'permessage-deflate');
ws.close();
});
});
});
describe('`isPaused`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'isPaused'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set === undefined);
});
it('indicates whether the websocket is paused', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.pause();
assert.ok(ws.isPaused);
ws.resume();
assert.ok(!ws.isPaused);
ws.close();
wss.close(done);
});
assert.ok(!ws.isPaused);
});
});
});
describe('`protocol`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'protocol'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set === undefined);
});
it('exposes the subprotocol selected by the server', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
assert.strictEqual(ws.extensions, '');
ws.on('open', () => {
assert.strictEqual(ws.protocol, 'foo');
ws.on('close', () => wss.close(done));
});
});
wss.on('connection', (ws) => {
assert.strictEqual(ws.protocol, 'foo');
ws.close();
});
});
});
describe('`readyState`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'readyState'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set === undefined);
});
it('defaults to `CONNECTING`', () => {
agent: new CustomAgent()
});
assert.strictEqual(ws.readyState, WebSocket.CONNECTING);
});
it('is set to `OPEN` once connection is established', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
assert.strictEqual(ws.readyState, WebSocket.OPEN);
ws.close();
});
ws.on('close', () => wss.close(done));
});
});
it('is set to `CLOSED` once connection is closed', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
wss.close(done);
});
ws.on('open', () => ws.close(1001));
});
});
it('is set to `CLOSED` once connection is terminated', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
wss.close(done);
});
ws.on('open', () => ws.terminate());
});
});
});
describe('`url`', () => {
it('is enumerable and configurable', () => {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
'url'
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set === undefined);
});
it('exposes the server url', () => {
const ws = new WebSocket(url, { agent: new CustomAgent() });
assert.strictEqual(ws.url, url);
});
});
});
describe('Events', () => {
it("emits an 'error' event if an error occurs", (done) => {
let clientCloseEventEmitted = false;
let serverClientCloseEventEmitted = false;
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(err.code, 'WS_ERR_INVALID_OPCODE');
assert.strictEqual(
err.message,
'Invalid WebSocket frame: invalid opcode 5'
);
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
clientCloseEventEmitted = true;
if (serverClientCloseEventEmitted) wss.close(done);
});
});
});
wss.on('connection', (ws) => {
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1002);
assert.deepStrictEqual(reason, EMPTY_BUFFER);
serverClientCloseEventEmitted = true;
if (clientCloseEventEmitted) wss.close(done);
});
ws._socket.write(Buffer.from([0x85, 0x00]));
});
});
it('does not re-emit `net.Socket` errors', (done) => {
const codes = ['EPIPE', 'ECONNABORTED', 'ECANCELED', 'ECONNRESET'];
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws._socket.on('error', (err) => {
assert.ok(err instanceof Error);
assert.ok(codes.includes(err.code), `Unexpected code: ${err.code}`);
ws.on('close', (code, message) => {
assert.strictEqual(code, 1006);
assert.strictEqual(message, EMPTY_BUFFER);
wss.close(done);
});
});
for (const client of wss.clients) client.terminate();
ws.send('foo');
ws.send('bar');
});
});
});
it("emits an 'upgrade' event", (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('upgrade', (res) => {
assert.ok(res instanceof http.IncomingMessage);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.close();
});
});
it("emits a 'ping' event", (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('ping', () => wss.close(done));
});
wss.on('connection', (ws) => {
ws.ping();
ws.close();
});
});
it("emits a 'pong' event", (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('pong', () => wss.close(done));
});
wss.on('connection', (ws) => {
ws.pong();
ws.close();
});
});
it("emits a 'redirect' event", (done) => {
const server = http.createServer();
const wss = new WebSocket.Server({ noServer: true, path: '/foo' });
server.once('upgrade', (req, socket) => {
socket.end('HTTP/1.1 302 Found\r\nLocation: /foo\r\n\r\n');
server.once('upgrade', (req, socket, head) => {
wss.handleUpgrade(req, socket, head, (ws) => {
ws.close();
});
});
});
server.listen(() => {
const port = server.address().port;
followRedirects: true
});
ws.on('redirect', (url, req) => {
assert.strictEqual(ws._redirects, 1);
assert.ok(req instanceof http.ClientRequest);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
server.close(done);
});
});
});
});
});
describe('Connection establishing', () => {
const server = http.createServer();
beforeEach((done) => server.listen(0, done));
afterEach((done) => server.close(done));
it('fails if the Upgrade header field value is not "websocket"', (done) => {
server.once('upgrade', (req, socket) => {
socket.on('end', socket.end);
socket.write(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Connection: Upgrade\r\n' +
'Upgrade: foo\r\n' +
'\r\n'
);
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Invalid Upgrade header');
done();
});
});
it('fails if the Sec-WebSocket-Accept header is invalid', (done) => {
server.once('upgrade', (req, socket) => {
socket.on('end', socket.end);
socket.write(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
'Sec-WebSocket-Accept: CxYS6+NgJSBG74mdgLvGscRvpns=\r\n' +
'\r\n'
);
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Invalid Sec-WebSocket-Accept header');
done();
});
});
it('close event is raised when server closes connection', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'\r\n'
);
});
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
done();
});
});
it('error is emitted if server aborts connection', (done) => {
server.once('upgrade', (req, socket) => {
socket.end(
`HTTP/1.1 401 ${http.STATUS_CODES[401]}\r\n` +
'Connection: close\r\n' +
'Content-type: text/html\r\n' +
`Content-Length: ${http.STATUS_CODES[401].length}\r\n` +
'\r\n'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Unexpected server response: 401');
done();
});
});
it('unexpected response can be read when sent by server', (done) => {
server.once('upgrade', (req, socket) => {
socket.end(
`HTTP/1.1 401 ${http.STATUS_CODES[401]}\r\n` +
'Connection: close\r\n' +
'Content-type: text/html\r\n' +
'Content-Length: 3\r\n' +
'\r\n' +
'foo'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', () => done(new Error("Unexpected 'error' event")));
ws.on('unexpected-response', (req, res) => {
assert.strictEqual(res.statusCode, 401);
let data = '';
res.on('data', (v) => {
data += v;
});
res.on('end', () => {
assert.strictEqual(data, 'foo');
done();
});
});
});
it('request can be aborted when unexpected response is sent by server', (done) => {
server.once('upgrade', (req, socket) => {
socket.end(
`HTTP/1.1 401 ${http.STATUS_CODES[401]}\r\n` +
'Connection: close\r\n' +
'Content-type: text/html\r\n' +
'Content-Length: 3\r\n' +
'\r\n' +
'foo'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', () => done(new Error("Unexpected 'error' event")));
ws.on('unexpected-response', (req, res) => {
assert.strictEqual(res.statusCode, 401);
res.on('end', done);
req.abort();
});
});
it('fails if the opening handshake timeout expires', (done) => {
server.once('upgrade', (req, socket) => socket.on('end', socket.end));
const port = server.address().port;
handshakeTimeout: 100
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Opening handshake has timed out');
done();
});
});
it('fails if an unexpected Sec-WebSocket-Extensions header is received', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'Sec-WebSocket-Extensions: foo\r\n' +
'\r\n'
);
});
perMessageDeflate: false
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'Server sent a Sec-WebSocket-Extensions header but no extension ' +
'was requested'
);
ws.on('close', () => done());
});
});
it('fails if the Sec-WebSocket-Extensions header is invalid (1/2)', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'Sec-WebSocket-Extensions: foo;=\r\n' +
'\r\n'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'Invalid Sec-WebSocket-Extensions header'
);
ws.on('close', () => done());
});
});
it('fails if the Sec-WebSocket-Extensions header is invalid (2/2)', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'Sec-WebSocket-Extensions: ' +
'permessage-deflate; client_max_window_bits=7\r\n' +
'\r\n'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'Invalid Sec-WebSocket-Extensions header'
);
ws.on('close', () => done());
});
});
it('fails if an unexpected extension is received (1/2)', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'Sec-WebSocket-Extensions: foo\r\n' +
'\r\n'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'Server indicated an extension that was not requested'
);
ws.on('close', () => done());
});
});
it('fails if an unexpected extension is received (2/2)', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'Sec-WebSocket-Extensions: permessage-deflate,foo\r\n' +
'\r\n'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'Server indicated an extension that was not requested'
);
ws.on('close', () => done());
});
});
it('fails if server sends a subprotocol when none was requested', (done) => {
const wss = new WebSocket.Server({ server });
wss.on('headers', (headers) => {
headers.push('Sec-WebSocket-Protocol: foo');
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'Server sent a subprotocol but none was requested'
);
ws.on('close', () => wss.close(done));
});
});
it('fails if server sends an invalid subprotocol (1/2)', (done) => {
const wss = new WebSocket.Server({
handleProtocols: () => 'baz',
server
});
'foo',
'bar'
]);
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Server sent an invalid subprotocol');
ws.on('close', () => wss.close(done));
});
});
it('fails if server sends an invalid subprotocol (2/2)', (done) => {
server.once('upgrade', (req, socket) => {
const key = crypto
.createHash('sha1')
.update(req.headers['sec-websocket-key'] + GUID)
.digest('base64');
socket.end(
'HTTP/1.1 101 Switching Protocols\r\n' +
'Upgrade: websocket\r\n' +
'Connection: Upgrade\r\n' +
`Sec-WebSocket-Accept: ${key}\r\n` +
'Sec-WebSocket-Protocol:\r\n' +
'\r\n'
);
});
'foo',
'bar'
]);
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Server sent an invalid subprotocol');
ws.on('close', () => done());
});
});
it('fails if server sends no subprotocol', (done) => {
const wss = new WebSocket.Server({
handleProtocols() {},
server
});
'foo',
'bar'
]);
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Server sent no subprotocol');
ws.on('close', () => wss.close(done));
});
});
it('does not follow redirects by default', (done) => {
server.once('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 301 Moved Permanently\r\n' +
'\r\n'
);
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Unexpected server response: 301');
assert.strictEqual(ws._redirects, 0);
ws.on('close', () => done());
});
});
it('honors the `followRedirects` option', (done) => {
const wss = new WebSocket.Server({ noServer: true, path: '/foo' });
server.once('upgrade', (req, socket) => {
socket.end('HTTP/1.1 302 Found\r\nLocation: /foo\r\n\r\n');
server.once('upgrade', (req, socket, head) => {
wss.handleUpgrade(req, socket, head, NOOP);
});
});
const port = server.address().port;
followRedirects: true
});
ws.on('open', () => {
assert.strictEqual(ws._redirects, 1);
ws.on('close', () => done());
ws.close();
});
});
it('honors the `maxRedirects` option', (done) => {
const onUpgrade = (req, socket) => {
socket.end('HTTP/1.1 302 Found\r\nLocation: /\r\n\r\n');
};
server.on('upgrade', onUpgrade);
followRedirects: true,
maxRedirects: 1
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'Maximum redirects exceeded');
assert.strictEqual(ws._redirects, 2);
server.removeListener('upgrade', onUpgrade);
ws.on('close', () => done());
});
});
it('emits an error if the redirect URL is invalid (1/2)', (done) => {
server.once('upgrade', (req, socket) => {
});
followRedirects: true
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof SyntaxError);
assert.strictEqual(err.message, 'Invalid URL: ws://');
assert.strictEqual(ws._redirects, 1);
ws.on('close', () => done());
});
});
it('emits an error if the redirect URL is invalid (2/2)', (done) => {
server.once('upgrade', (req, socket) => {
});
followRedirects: true
});
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof SyntaxError);
assert.strictEqual(
err.message,
'The URL\'s protocol must be one of "ws:", "wss:", or "ws+unix:"'
);
assert.strictEqual(ws._redirects, 1);
ws.on('close', () => done());
});
});
it('uses the first url userinfo when following redirects', (done) => {
const wss = new WebSocket.Server({ noServer: true, path: '/foo' });
const authorization = 'Basic Zm9vOmJhcg==';
server.once('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
server.once('upgrade', (req, socket, head) => {
wss.handleUpgrade(req, socket, head, (ws, req) => {
assert.strictEqual(req.headers.authorization, authorization);
ws.close();
});
});
});
const port = server.address().port;
followRedirects: true
});
assert.strictEqual(ws._req.getHeader('Authorization'), authorization);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
wss.close(done);
});
});
describe('When moving away from a secure context', () => {
function proxy(httpServer, httpsServer) {
const server = net.createServer({ allowHalfOpen: true });
server.on('connection', (socket) => {
socket.on('readable', function read() {
socket.removeListener('readable', read);
const buf = socket.read(1);
const target = buf[0] === 22 ? httpsServer : httpServer;
socket.unshift(buf);
target.emit('connection', socket);
});
});
return server;
}
describe("If there is no 'redirect' event listener", () => {
it('drops the `auth` option', (done) => {
const httpServer = http.createServer();
const httpsServer = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const server = proxy(httpServer, httpsServer);
server.listen(() => {
const port = server.address().port;
httpsServer.on('upgrade', (req, socket) => {
socket.on('error', NOOP);
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const wss = new WebSocket.Server({ server: httpServer });
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
ws.close();
});
auth: 'foo:bar',
followRedirects: true,
rejectUnauthorized: false
});
assert.strictEqual(
ws._req.getHeader('Authorization'),
'Basic Zm9vOmJhcg=='
);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
server.close(done);
});
});
});
it('drops the Authorization and Cookie headers', (done) => {
const httpServer = http.createServer();
const httpsServer = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const server = proxy(httpServer, httpsServer);
server.listen(() => {
const port = server.address().port;
httpsServer.on('upgrade', (req, socket) => {
socket.on('error', NOOP);
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
const wss = new WebSocket.Server({ server: httpServer });
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
assert.strictEqual(req.headers.cookie, undefined);
assert.strictEqual(req.headers.host, headers.host);
ws.close();
});
followRedirects: true,
headers,
rejectUnauthorized: false
});
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
server.close(done);
});
});
});
});
describe("If there is at least one 'redirect' event listener", () => {
it('does not drop any headers by default', (done) => {
const httpServer = http.createServer();
const httpsServer = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const server = proxy(httpServer, httpsServer);
server.listen(() => {
const port = server.address().port;
httpsServer.on('upgrade', (req, socket) => {
socket.on('error', NOOP);
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
const wss = new WebSocket.Server({ server: httpServer });
wss.on('connection', (ws, req) => {
assert.strictEqual(
req.headers.authorization,
headers.authorization
);
assert.strictEqual(req.headers.cookie, headers.cookie);
assert.strictEqual(req.headers.host, headers.host);
ws.close();
});
followRedirects: true,
headers,
rejectUnauthorized: false
});
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('redirect', (url, req) => {
assert.strictEqual(ws._redirects, 1);
assert.notStrictEqual(firstRequest, req);
assert.strictEqual(
req.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(req.getHeader('Cookie'), headers.cookie);
assert.strictEqual(req.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
server.close(done);
});
});
});
});
});
});
describe('When the redirect host is different', () => {
describe("If there is no 'redirect' event listener", () => {
it('drops the `auth` option', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
server.once('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const ws = new WebSocket(
{
auth: 'foo:bar',
followRedirects: true
}
);
assert.strictEqual(
ws._req.getHeader('Authorization'),
'Basic Zm9vOmJhcg=='
);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
wss.close(done);
});
});
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
ws.close();
});
});
it('drops the Authorization, Cookie and Host headers (1/4)', (done) => {
// Test the `ws:` to `ws:` case.
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
server.once('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
const ws = new WebSocket(
{ followRedirects: true, headers }
);
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
wss.close(done);
});
});
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
assert.strictEqual(req.headers.cookie, undefined);
assert.strictEqual(
req.headers.host,
`localhost:${wss.address().port}`
);
ws.close();
});
});
it('drops the Authorization, Cookie and Host headers (2/4)', function (done) {
if (process.platform === 'win32') return this.skip();
// Test the `ws:` to `ws+unix:` case.
const socketPath = path.join(
os.tmpdir(),
`ws.${crypto.randomBytes(16).toString('hex')}.sock`
);
server.once('upgrade', (req, socket) => {
socket.end(
);
});
const redirectedServer = http.createServer();
const wss = new WebSocket.Server({ server: redirectedServer });
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
assert.strictEqual(req.headers.cookie, undefined);
assert.strictEqual(req.headers.host, 'localhost');
ws.close();
});
redirectedServer.listen(socketPath, () => {
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
const ws = new WebSocket(
{ followRedirects: true, headers }
);
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
redirectedServer.close(done);
});
});
});
it('drops the Authorization, Cookie and Host headers (3/4)', function (done) {
if (process.platform === 'win32') return this.skip();
// Test the `ws+unix:` to `ws+unix:` case.
const redirectingServerSocketPath = path.join(
os.tmpdir(),
`ws.${crypto.randomBytes(16).toString('hex')}.sock`
);
const redirectedServerSocketPath = path.join(
os.tmpdir(),
`ws.${crypto.randomBytes(16).toString('hex')}.sock`
);
const redirectingServer = http.createServer();
redirectingServer.on('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const redirectedServer = http.createServer();
const wss = new WebSocket.Server({ server: redirectedServer });
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
assert.strictEqual(req.headers.cookie, undefined);
assert.strictEqual(req.headers.host, 'localhost');
ws.close();
});
redirectingServer.listen(redirectingServerSocketPath, listening);
redirectedServer.listen(redirectedServerSocketPath, listening);
let callCount = 0;
function listening() {
if (++callCount !== 2) return;
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
const ws = new WebSocket(
{ followRedirects: true, headers }
);
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(
ws.url,
);
assert.strictEqual(ws._redirects, 1);
redirectingServer.close();
redirectedServer.close(done);
});
}
});
it('drops the Authorization, Cookie and Host headers (4/4)', function (done) {
if (process.platform === 'win32') return this.skip();
// Test the `ws+unix:` to `ws:` case.
const redirectingServer = http.createServer();
const redirectedServer = http.createServer();
const wss = new WebSocket.Server({ server: redirectedServer });
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
assert.strictEqual(req.headers.cookie, undefined);
assert.strictEqual(
req.headers.host,
`localhost:${redirectedServer.address().port}`
);
ws.close();
});
const socketPath = path.join(
os.tmpdir(),
`ws.${crypto.randomBytes(16).toString('hex')}.sock`
);
redirectingServer.listen(socketPath, listening);
redirectedServer.listen(0, listening);
let callCount = 0;
function listening() {
if (++callCount !== 2) return;
const port = redirectedServer.address().port;
redirectingServer.on('upgrade', (req, socket) => {
socket.end(
);
});
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
followRedirects: true,
headers
});
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws._redirects, 1);
redirectingServer.close();
redirectedServer.close(done);
});
}
});
});
describe("If there is at least one 'redirect' event listener", () => {
it('does not drop any headers by default', (done) => {
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar',
host: 'foo'
};
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
server.once('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const ws = new WebSocket(
{ followRedirects: true, headers }
);
const firstRequest = ws._req;
assert.strictEqual(
firstRequest.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(
firstRequest.getHeader('Cookie'),
headers.cookie
);
assert.strictEqual(firstRequest.getHeader('Host'), headers.host);
ws.on('redirect', (url, req) => {
assert.strictEqual(ws._redirects, 1);
assert.notStrictEqual(firstRequest, req);
assert.strictEqual(
req.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(req.getHeader('Cookie'), headers.cookie);
assert.strictEqual(req.getHeader('Host'), headers.host);
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
wss.close(done);
});
});
});
wss.on('connection', (ws, req) => {
assert.strictEqual(
req.headers.authorization,
headers.authorization
);
assert.strictEqual(req.headers.cookie, headers.cookie);
assert.strictEqual(req.headers.host, headers.host);
ws.close();
});
});
});
});
describe("In a listener of the 'redirect' event", () => {
it('allows to abort the request without swallowing errors', (done) => {
server.once('upgrade', (req, socket) => {
socket.end('HTTP/1.1 302 Found\r\nLocation: /foo\r\n\r\n');
});
const port = server.address().port;
followRedirects: true
});
ws.on('redirect', (url, req) => {
assert.strictEqual(ws._redirects, 1);
req.on('socket', () => {
req.abort();
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.message, 'socket hang up');
ws.on('close', (code) => {
assert.strictEqual(code, 1006);
done();
});
});
});
});
it('allows to remove headers', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
server.once('upgrade', (req, socket) => {
socket.end(
'HTTP/1.1 302 Found\r\n' +
);
});
const headers = {
authorization: 'Basic Zm9vOmJhcg==',
cookie: 'foo=bar'
};
followRedirects: true,
headers
});
ws.on('redirect', (url, req) => {
assert.strictEqual(ws._redirects, 1);
assert.strictEqual(
req.getHeader('Authorization'),
headers.authorization
);
assert.strictEqual(req.getHeader('Cookie'), headers.cookie);
req.removeHeader('authorization');
req.removeHeader('cookie');
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
wss.close(done);
});
});
});
wss.on('connection', (ws, req) => {
assert.strictEqual(req.headers.authorization, undefined);
assert.strictEqual(req.headers.cookie, undefined);
ws.close();
});
});
});
});
describe('Connection with query string', () => {
it('connects when pathname is not null', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
ws.on('open', () => {
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.close();
});
});
it('connects when pathname is null', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const port = wss.address().port;
ws.on('open', () => {
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.close();
});
});
});
describe('#pause', () => {
it('does nothing if `readyState` is `CONNECTING` or `CLOSED`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
assert.strictEqual(ws.readyState, WebSocket.CONNECTING);
assert.ok(!ws.isPaused);
ws.pause();
assert.ok(!ws.isPaused);
ws.on('open', () => {
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.pause();
assert.ok(!ws.isPaused);
wss.close(done);
});
ws.close();
});
});
});
it('pauses the socket', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
assert.ok(!ws.isPaused);
assert.ok(!ws._socket.isPaused());
ws.pause();
assert.ok(ws.isPaused);
assert.ok(ws._socket.isPaused());
ws.terminate();
wss.close(done);
});
});
});
describe('#ping', () => {
it('throws an error if `readyState` is `CONNECTING`', () => {
lookup() {}
});
assert.throws(
() => ws.ping(),
/^Error: WebSocket is not open: readyState 0 \(CONNECTING\)$/
);
assert.throws(
() => ws.ping(NOOP),
/^Error: WebSocket is not open: readyState 0 \(CONNECTING\)$/
);
});
it('increases `bufferedAmount` if `readyState` is 2 or 3', (done) => {
lookup() {}
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
assert.strictEqual(ws.readyState, WebSocket.CLOSING);
assert.strictEqual(ws.bufferedAmount, 0);
ws.ping('hi');
assert.strictEqual(ws.bufferedAmount, 2);
ws.ping();
assert.strictEqual(ws.bufferedAmount, 2);
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.ping('hi');
assert.strictEqual(ws.bufferedAmount, 4);
ws.ping();
assert.strictEqual(ws.bufferedAmount, 4);
done();
});
});
ws.close();
});
it('calls the callback w/ an error if `readyState` is 2 or 3', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
ws.close();
assert.strictEqual(ws.bufferedAmount, 0);
ws.ping('hi', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket is not open: readyState 2 (CLOSING)'
);
assert.strictEqual(ws.bufferedAmount, 2);
ws.on('close', () => {
ws.ping((err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket is not open: readyState 3 (CLOSED)'
);
assert.strictEqual(ws.bufferedAmount, 2);
wss.close(done);
});
});
});
});
});
it('can send a ping with no data', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.ping(() => {
ws.ping();
ws.close();
});
});
});
wss.on('connection', (ws) => {
let pings = 0;
ws.on('ping', (data) => {
assert.ok(Buffer.isBuffer(data));
assert.strictEqual(data.length, 0);
if (++pings === 2) wss.close(done);
});
});
});
it('can send a ping with data', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.ping('hi', () => {
ws.ping('hi', true);
ws.close();
});
});
});
wss.on('connection', (ws) => {
let pings = 0;
ws.on('ping', (message) => {
assert.strictEqual(message.toString(), 'hi');
if (++pings === 2) wss.close(done);
});
});
});
it('can send numbers as ping payload', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.ping(0);
ws.close();
});
});
wss.on('connection', (ws) => {
ws.on('ping', (message) => {
assert.strictEqual(message.toString(), '0');
wss.close(done);
});
});
});
it('throws an error if the data size is greater than 125 bytes', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
assert.throws(
() => ws.ping(Buffer.alloc(126)),
/^RangeError: The data size must not be greater than 125 bytes$/
);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.close();
});
});
});
describe('#pong', () => {
it('throws an error if `readyState` is `CONNECTING`', () => {
lookup() {}
});
assert.throws(
() => ws.pong(),
/^Error: WebSocket is not open: readyState 0 \(CONNECTING\)$/
);
assert.throws(
() => ws.pong(NOOP),
/^Error: WebSocket is not open: readyState 0 \(CONNECTING\)$/
);
});
it('increases `bufferedAmount` if `readyState` is 2 or 3', (done) => {
lookup() {}
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
assert.strictEqual(ws.readyState, WebSocket.CLOSING);
assert.strictEqual(ws.bufferedAmount, 0);
ws.pong('hi');
assert.strictEqual(ws.bufferedAmount, 2);
ws.pong();
assert.strictEqual(ws.bufferedAmount, 2);
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.pong('hi');
assert.strictEqual(ws.bufferedAmount, 4);
ws.pong();
assert.strictEqual(ws.bufferedAmount, 4);
done();
});
});
ws.close();
});
it('calls the callback w/ an error if `readyState` is 2 or 3', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
ws.close();
assert.strictEqual(ws.bufferedAmount, 0);
ws.pong('hi', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket is not open: readyState 2 (CLOSING)'
);
assert.strictEqual(ws.bufferedAmount, 2);
ws.on('close', () => {
ws.pong((err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket is not open: readyState 3 (CLOSED)'
);
assert.strictEqual(ws.bufferedAmount, 2);
wss.close(done);
});
});
});
});
});
it('can send a pong with no data', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.pong(() => {
ws.pong();
ws.close();
});
});
});
wss.on('connection', (ws) => {
let pongs = 0;
ws.on('pong', (data) => {
assert.ok(Buffer.isBuffer(data));
assert.strictEqual(data.length, 0);
if (++pongs === 2) wss.close(done);
});
});
});
it('can send a pong with data', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.pong('hi', () => {
ws.pong('hi', true);
ws.close();
});
});
});
wss.on('connection', (ws) => {
let pongs = 0;
ws.on('pong', (message) => {
assert.strictEqual(message.toString(), 'hi');
if (++pongs === 2) wss.close(done);
});
});
});
it('can send numbers as pong payload', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.pong(0);
ws.close();
});
});
wss.on('connection', (ws) => {
ws.on('pong', (message) => {
assert.strictEqual(message.toString(), '0');
wss.close(done);
});
});
});
it('throws an error if the data size is greater than 125 bytes', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
assert.throws(
() => ws.pong(Buffer.alloc(126)),
/^RangeError: The data size must not be greater than 125 bytes$/
);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.close();
});
});
});
describe('#resume', () => {
it('does nothing if `readyState` is `CONNECTING` or `CLOSED`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
assert.strictEqual(ws.readyState, WebSocket.CONNECTING);
assert.ok(!ws.isPaused);
// Verify that no exception is thrown.
ws.resume();
ws.on('open', () => {
ws.pause();
assert.ok(ws.isPaused);
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.resume();
assert.ok(ws.isPaused);
wss.close(done);
});
ws.terminate();
});
});
});
it('resumes the socket', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
assert.ok(!ws.isPaused);
assert.ok(!ws._socket.isPaused());
ws.pause();
assert.ok(ws.isPaused);
assert.ok(ws._socket.isPaused());
ws.resume();
assert.ok(!ws.isPaused);
assert.ok(!ws._socket.isPaused());
ws.close();
wss.close(done);
});
});
});
describe('#send', () => {
it('throws an error if `readyState` is `CONNECTING`', () => {
lookup() {}
});
assert.throws(
() => ws.send('hi'),
/^Error: WebSocket is not open: readyState 0 \(CONNECTING\)$/
);
assert.throws(
() => ws.send('hi', NOOP),
/^Error: WebSocket is not open: readyState 0 \(CONNECTING\)$/
);
});
it('increases `bufferedAmount` if `readyState` is 2 or 3', (done) => {
lookup() {}
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
assert.strictEqual(ws.readyState, WebSocket.CLOSING);
assert.strictEqual(ws.bufferedAmount, 0);
ws.send('hi');
assert.strictEqual(ws.bufferedAmount, 2);
ws.send();
assert.strictEqual(ws.bufferedAmount, 2);
ws.on('close', () => {
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.send('hi');
assert.strictEqual(ws.bufferedAmount, 4);
ws.send();
assert.strictEqual(ws.bufferedAmount, 4);
done();
});
});
ws.close();
});
it('calls the callback w/ an error if `readyState` is 2 or 3', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
ws.close();
assert.strictEqual(ws.bufferedAmount, 0);
ws.send('hi', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket is not open: readyState 2 (CLOSING)'
);
assert.strictEqual(ws.bufferedAmount, 2);
ws.on('close', () => {
ws.send('hi', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket is not open: readyState 3 (CLOSED)'
);
assert.strictEqual(ws.bufferedAmount, 4);
wss.close(done);
});
});
});
});
});
it('can send a big binary message', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const array = new Float32Array(5 * 1024 * 1024);
for (let i = 0; i < array.length; i++) {
array[i] = i / 5;
}
ws.on('open', () => ws.send(array));
ws.on('message', (msg, isBinary) => {
assert.deepStrictEqual(msg, Buffer.from(array.buffer));
assert.ok(isBinary);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.ok(isBinary);
ws.send(msg);
ws.close();
});
});
});
it('can send text data', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => ws.send('hi'));
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, Buffer.from('hi'));
assert.ok(!isBinary);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
ws.send(msg, { binary: isBinary });
ws.close();
});
});
});
it('does not override the `fin` option', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.send('fragment', { fin: false });
ws.send('fragment', { fin: true });
ws.close();
});
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.deepStrictEqual(msg, Buffer.from('fragmentfragment'));
assert.ok(!isBinary);
wss.close(done);
});
});
});
it('sends numbers as strings', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.send(0);
ws.close();
});
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.deepStrictEqual(msg, Buffer.from('0'));
assert.ok(!isBinary);
wss.close(done);
});
});
});
it('can send a `TypedArray`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const array = new Float32Array(6);
for (let i = 0; i < array.length; ++i) {
array[i] = i / 2;
}
const partial = array.subarray(2, 5);
const buf = Buffer.from(
partial.buffer,
partial.byteOffset,
partial.byteLength
);
ws.on('open', () => {
ws.send(partial);
ws.close();
});
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, buf);
assert.ok(isBinary);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.ok(isBinary);
ws.send(msg);
});
});
});
it('can send an `ArrayBuffer`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const array = new Float32Array(5);
for (let i = 0; i < array.length; ++i) {
array[i] = i / 2;
}
ws.on('open', () => {
ws.send(array.buffer);
ws.close();
});
ws.onmessage = (event) => {
assert.ok(event.data.equals(Buffer.from(array.buffer)));
wss.close(done);
};
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.ok(isBinary);
ws.send(msg);
});
});
});
it('can send a `Buffer`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const buf = Buffer.from('foobar');
ws.on('open', () => {
ws.send(buf);
ws.close();
});
ws.onmessage = (event) => {
assert.deepStrictEqual(event.data, buf);
wss.close(done);
};
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.ok(isBinary);
ws.send(msg);
});
});
});
it('calls the callback when data is written out', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.send('hi', (err) => {
assert.ifError(err);
wss.close(done);
});
});
});
wss.on('connection', (ws) => {
ws.close();
});
});
it('works when the `data` argument is falsy', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws.send();
ws.close();
});
});
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
assert.strictEqual(message, EMPTY_BUFFER);
assert.ok(isBinary);
wss.close(done);
});
});
});
it('honors the `mask` option', (done) => {
let clientCloseEventEmitted = false;
let serverClientCloseEventEmitted = false;
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => ws.send('hi', { mask: false }));
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1002);
assert.deepStrictEqual(reason, EMPTY_BUFFER);
clientCloseEventEmitted = true;
if (serverClientCloseEventEmitted) wss.close(done);
});
});
wss.on('connection', (ws) => {
const chunks = [];
ws._socket.prependListener('data', (chunk) => {
chunks.push(chunk);
});
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(
err.message,
'Invalid WebSocket frame: MASK must be set'
);
assert.ok(
Buffer.concat(chunks).slice(0, 2).equals(Buffer.from('8102', 'hex'))
);
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
serverClientCloseEventEmitted = true;
if (clientCloseEventEmitted) wss.close(done);
});
});
});
});
});
describe('#close', () => {
it('closes the connection if called while connecting (1/3)', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => wss.close(done));
});
ws.close(1001);
});
});
it('closes the connection if called while connecting (2/3)', (done) => {
const wss = new WebSocket.Server(
{
verifyClient: (info, cb) => setTimeout(cb, 300, true),
port: 0
},
() => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => wss.close(done));
});
setTimeout(() => ws.close(1001), 150);
}
);
});
it('closes the connection if called while connecting (3/3)', (done) => {
const server = http.createServer();
server.listen(0, () => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => {
server.close(done);
});
});
ws.on('unexpected-response', (req, res) => {
assert.strictEqual(res.statusCode, 502);
const chunks = [];
res.on('data', (chunk) => {
chunks.push(chunk);
});
res.on('end', () => {
assert.strictEqual(Buffer.concat(chunks).toString(), 'foo');
ws.close();
});
});
});
server.on('upgrade', (req, socket) => {
socket.on('end', socket.end);
socket.write(
`HTTP/1.1 502 ${http.STATUS_CODES[502]}\r\n` +
'Connection: keep-alive\r\n' +
'Content-type: text/html\r\n' +
'Content-Length: 3\r\n' +
'\r\n' +
'foo'
);
});
});
it('can be called from an error listener while connecting', (done) => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.code, 'ECONNREFUSED');
ws.close();
ws.on('close', () => done());
});
}).timeout(4000);
it("can be called from a listener of the 'redirect' event", (done) => {
const server = http.createServer();
server.once('upgrade', (req, socket) => {
socket.end('HTTP/1.1 302 Found\r\nLocation: /foo\r\n\r\n');
});
server.listen(() => {
const port = server.address().port;
followRedirects: true
});
ws.on('open', () => {
done(new Error("Unexpected 'open' event"));
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', (code) => {
assert.strictEqual(code, 1006);
server.close(done);
});
});
ws.on('redirect', () => {
ws.close();
});
});
});
it("can be called from a listener of the 'upgrade' event", (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => wss.close(done));
});
ws.on('upgrade', () => ws.close());
});
});
it('sends the close status code only when necessary', (done) => {
let sent;
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => {
ws._socket.once('data', (data) => {
sent = data;
});
});
});
wss.on('connection', (ws) => {
ws._socket.once('data', (received) => {
assert.deepStrictEqual(
received.slice(0, 2),
Buffer.from([0x88, 0x80])
);
assert.deepStrictEqual(sent, Buffer.from([0x88, 0x00]));
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1005);
assert.strictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
});
ws.close();
});
});
it('works when close reason is not specified', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => ws.close(1000));
});
wss.on('connection', (ws) => {
ws.on('close', (code, message) => {
assert.strictEqual(code, 1000);
assert.deepStrictEqual(message, EMPTY_BUFFER);
wss.close(done);
});
});
});
it('works when close reason is specified', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => ws.close(1000, 'some reason'));
});
wss.on('connection', (ws) => {
ws.on('close', (code, message) => {
assert.strictEqual(code, 1000);
assert.deepStrictEqual(message, Buffer.from('some reason'));
wss.close(done);
});
});
});
it('permits all buffered data to be delivered', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: { threshold: 0 },
port: 0
},
() => {
const messages = [];
ws.on('message', (message, isBinary) => {
assert.ok(!isBinary);
messages.push(message.toString());
});
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.deepStrictEqual(messages, ['foo', 'bar', 'baz']);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
const callback = (err) => assert.ifError(err);
ws.send('foo', callback);
ws.send('bar', callback);
ws.send('baz', callback);
ws.close();
ws.close();
});
});
it('allows close code 1013', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', (code) => {
assert.strictEqual(code, 1013);
wss.close(done);
});
});
wss.on('connection', (ws) => ws.close(1013));
});
it('allows close code 1014', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', (code) => {
assert.strictEqual(code, 1014);
wss.close(done);
});
});
wss.on('connection', (ws) => ws.close(1014));
});
it('does nothing if `readyState` is `CLOSED`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.close();
wss.close(done);
});
});
wss.on('connection', (ws) => ws.close());
});
it('sets a timer for the closing handshake to complete', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1000);
assert.deepStrictEqual(reason, Buffer.from('some reason'));
wss.close(done);
});
ws.on('open', () => {
let callbackCalled = false;
assert.strictEqual(ws._closeTimer, null);
ws.send('foo', () => {
callbackCalled = true;
});
ws.close(1000, 'some reason');
//
// Check that the close timer is set even if the `Sender.close()`
// callback is not called.
//
assert.strictEqual(callbackCalled, false);
assert.strictEqual(ws._closeTimer._idleTimeout, 30000);
});
});
});
});
describe('#terminate', () => {
it('closes the connection if called while connecting (1/2)', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => wss.close(done));
});
ws.terminate();
});
});
it('closes the connection if called while connecting (2/2)', (done) => {
const wss = new WebSocket.Server(
{
verifyClient: (info, cb) => setTimeout(cb, 300, true),
port: 0
},
() => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => wss.close(done));
});
setTimeout(() => ws.terminate(), 150);
}
);
});
it('can be called from an error listener while connecting', (done) => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(err.code, 'ECONNREFUSED');
ws.terminate();
ws.on('close', () => done());
});
}).timeout(4000);
it("can be called from a listener of the 'redirect' event", (done) => {
const server = http.createServer();
server.once('upgrade', (req, socket) => {
socket.end('HTTP/1.1 302 Found\r\nLocation: /foo\r\n\r\n');
});
server.listen(() => {
const port = server.address().port;
followRedirects: true
});
ws.on('open', () => {
done(new Error("Unexpected 'open' event"));
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', (code) => {
assert.strictEqual(code, 1006);
server.close(done);
});
});
ws.on('redirect', () => {
ws.terminate();
});
});
});
it("can be called from a listener of the 'upgrade' event", (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('open', () => done(new Error("Unexpected 'open' event")));
ws.on('error', (err) => {
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'WebSocket was closed before the connection was established'
);
ws.on('close', () => wss.close(done));
});
ws.on('upgrade', () => ws.terminate());
});
});
it('does nothing if `readyState` is `CLOSED`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('close', (code) => {
assert.strictEqual(code, 1006);
assert.strictEqual(ws.readyState, WebSocket.CLOSED);
ws.terminate();
wss.close(done);
});
});
wss.on('connection', (ws) => ws.terminate());
});
});
describe('WHATWG API emulation', () => {
it('supports the `on{close,error,message,open}` attributes', () => {
for (const property of ['onclose', 'onerror', 'onmessage', 'onopen']) {
const descriptor = Object.getOwnPropertyDescriptor(
WebSocket.prototype,
property
);
assert.strictEqual(descriptor.configurable, true);
assert.strictEqual(descriptor.enumerable, true);
assert.ok(descriptor.get !== undefined);
assert.ok(descriptor.set !== undefined);
}
assert.strictEqual(ws.onmessage, null);
assert.strictEqual(ws.onclose, null);
assert.strictEqual(ws.onerror, null);
assert.strictEqual(ws.onopen, null);
ws.onmessage = NOOP;
ws.onerror = NOOP;
ws.onclose = NOOP;
ws.onopen = NOOP;
assert.strictEqual(ws.onmessage, NOOP);
assert.strictEqual(ws.onclose, NOOP);
assert.strictEqual(ws.onerror, NOOP);
assert.strictEqual(ws.onopen, NOOP);
ws.onmessage = 'foo';
assert.strictEqual(ws.onmessage, null);
assert.strictEqual(ws.listenerCount('message'), 0);
});
it('works like the `EventEmitter` interface', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.onmessage = (messageEvent) => {
assert.strictEqual(messageEvent.data, 'foo');
ws.onclose = (closeEvent) => {
assert.strictEqual(closeEvent.wasClean, true);
assert.strictEqual(closeEvent.code, 1005);
assert.strictEqual(closeEvent.reason, '');
wss.close(done);
};
ws.close();
};
ws.onopen = () => ws.send('foo');
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
ws.send(msg, { binary: isBinary });
});
});
});
it("doesn't return listeners added with `on`", () => {
ws.on('open', NOOP);
assert.deepStrictEqual(ws.listeners('open'), [NOOP]);
assert.strictEqual(ws.onopen, null);
});
it("doesn't remove listeners added with `on`", () => {
ws.on('close', NOOP);
ws.onclose = NOOP;
let listeners = ws.listeners('close');
assert.strictEqual(listeners.length, 2);
assert.strictEqual(listeners[0], NOOP);
assert.strictEqual(listeners[1][kListener], NOOP);
ws.onclose = NOOP;
listeners = ws.listeners('close');
assert.strictEqual(listeners.length, 2);
assert.strictEqual(listeners[0], NOOP);
assert.strictEqual(listeners[1][kListener], NOOP);
});
it('supports the `addEventListener` method', () => {
const events = [];
ws.addEventListener('foo', () => {});
assert.strictEqual(ws.listenerCount('foo'), 0);
ws.addEventListener('open', () => {
events.push('open');
assert.strictEqual(ws.listenerCount('open'), 1);
});
assert.strictEqual(ws.listenerCount('open'), 1);
ws.addEventListener(
'message',
() => {
events.push('message');
assert.strictEqual(ws.listenerCount('message'), 0);
},
{ once: true }
);
assert.strictEqual(ws.listenerCount('message'), 1);
ws.emit('open');
ws.emit('message', EMPTY_BUFFER, false);
assert.deepStrictEqual(events, ['open', 'message']);
});
it("doesn't return listeners added with `addEventListener`", () => {
ws.addEventListener('open', NOOP);
const listeners = ws.listeners('open');
assert.strictEqual(listeners.length, 1);
assert.strictEqual(listeners[0][kListener], NOOP);
assert.strictEqual(ws.onopen, null);
});
it("doesn't remove listeners added with `addEventListener`", () => {
ws.addEventListener('close', NOOP);
ws.onclose = NOOP;
let listeners = ws.listeners('close');
assert.strictEqual(listeners.length, 2);
assert.strictEqual(listeners[0][kListener], NOOP);
assert.strictEqual(listeners[1][kListener], NOOP);
ws.onclose = NOOP;
listeners = ws.listeners('close');
assert.strictEqual(listeners.length, 2);
assert.strictEqual(listeners[0][kListener], NOOP);
assert.strictEqual(listeners[1][kListener], NOOP);
});
it('supports the `removeEventListener` method', () => {
ws.addEventListener('message', NOOP);
ws.addEventListener('open', NOOP);
assert.strictEqual(ws.listeners('message')[0][kListener], NOOP);
assert.strictEqual(ws.listeners('open')[0][kListener], NOOP);
ws.removeEventListener('message', () => {});
assert.strictEqual(ws.listeners('message')[0][kListener], NOOP);
ws.removeEventListener('message', NOOP);
ws.removeEventListener('open', NOOP);
assert.strictEqual(ws.listenerCount('message'), 0);
assert.strictEqual(ws.listenerCount('open'), 0);
ws.addEventListener('message', NOOP, { once: true });
ws.addEventListener('open', NOOP, { once: true });
assert.strictEqual(ws.listeners('message')[0][kListener], NOOP);
assert.strictEqual(ws.listeners('open')[0][kListener], NOOP);
ws.removeEventListener('message', () => {});
assert.strictEqual(ws.listeners('message')[0][kListener], NOOP);
ws.removeEventListener('message', NOOP);
ws.removeEventListener('open', NOOP);
assert.strictEqual(ws.listenerCount('message'), 0);
assert.strictEqual(ws.listenerCount('open'), 0);
// Multiple listeners.
ws.addEventListener('message', NOOP);
ws.addEventListener('message', NOOP);
assert.strictEqual(ws.listeners('message')[0][kListener], NOOP);
assert.strictEqual(ws.listeners('message')[1][kListener], NOOP);
ws.removeEventListener('message', NOOP);
assert.strictEqual(ws.listeners('message')[0][kListener], NOOP);
ws.removeEventListener('message', NOOP);
assert.strictEqual(ws.listenerCount('message'), 0);
// Listeners not added with `websocket.addEventListener()`.
ws.on('message', NOOP);
assert.deepStrictEqual(ws.listeners('message'), [NOOP]);
ws.removeEventListener('message', NOOP);
assert.deepStrictEqual(ws.listeners('message'), [NOOP]);
ws.onclose = NOOP;
assert.strictEqual(ws.listeners('close')[0][kListener], NOOP);
ws.removeEventListener('close', NOOP);
assert.strictEqual(ws.listeners('close')[0][kListener], NOOP);
});
it('wraps text data in a `MessageEvent`', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.addEventListener('open', () => {
ws.send('hi');
ws.close();
});
ws.addEventListener('message', (event) => {
assert.ok(event instanceof MessageEvent);
assert.strictEqual(event.data, 'hi');
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
ws.send(msg, { binary: isBinary });
});
});
});
it('receives a `CloseEvent` when server closes (1000)', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.addEventListener('close', (event) => {
assert.ok(event instanceof CloseEvent);
assert.ok(event.wasClean);
assert.strictEqual(event.reason, '');
assert.strictEqual(event.code, 1000);
wss.close(done);
});
});
wss.on('connection', (ws) => ws.close(1000));
});
it('receives a `CloseEvent` when server closes (4000)', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.addEventListener('close', (event) => {
assert.ok(event instanceof CloseEvent);
assert.ok(event.wasClean);
assert.strictEqual(event.reason, 'some daft reason');
assert.strictEqual(event.code, 4000);
wss.close(done);
});
});
wss.on('connection', (ws) => ws.close(4000, 'some daft reason'));
});
it('sets `target` and `type` on events', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
const err = new Error('forced');
ws.addEventListener('open', (event) => {
assert.ok(event instanceof Event);
assert.strictEqual(event.type, 'open');
assert.strictEqual(event.target, ws);
});
ws.addEventListener('message', (event) => {
assert.ok(event instanceof MessageEvent);
assert.strictEqual(event.type, 'message');
assert.strictEqual(event.target, ws);
ws.close();
});
ws.addEventListener('close', (event) => {
assert.ok(event instanceof CloseEvent);
assert.strictEqual(event.type, 'close');
assert.strictEqual(event.target, ws);
ws.emit('error', err);
});
ws.addEventListener('error', (event) => {
assert.ok(event instanceof ErrorEvent);
assert.strictEqual(event.message, 'forced');
assert.strictEqual(event.type, 'error');
assert.strictEqual(event.target, ws);
assert.strictEqual(event.error, err);
wss.close(done);
});
});
wss.on('connection', (client) => client.send('hi'));
});
it('passes binary data as a Node.js `Buffer` by default', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.onmessage = (evt) => {
assert.ok(Buffer.isBuffer(evt.data));
wss.close(done);
};
});
wss.on('connection', (ws) => {
ws.send(new Uint8Array(4096));
ws.close();
});
});
it('ignores `binaryType` for text messages', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.binaryType = 'arraybuffer';
ws.onmessage = (evt) => {
assert.strictEqual(evt.data, 'foo');
wss.close(done);
};
});
wss.on('connection', (ws) => {
ws.send('foo');
ws.close();
});
});
it('allows to update `binaryType` on the fly', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
function testType(binaryType, next) {
const buf = Buffer.from(binaryType);
ws.binaryType = binaryType;
ws.onmessage = (evt) => {
if (binaryType === 'nodebuffer') {
assert.ok(Buffer.isBuffer(evt.data));
assert.ok(evt.data.equals(buf));
} else if (binaryType === 'arraybuffer') {
assert.ok(evt.data instanceof ArrayBuffer);
assert.ok(Buffer.from(evt.data).equals(buf));
} else if (binaryType === 'fragments') {
assert.deepStrictEqual(evt.data, [buf]);
}
next();
};
ws.send(buf);
}
ws.onopen = () => {
testType('nodebuffer', () => {
testType('arraybuffer', () => {
testType('fragments', () => {
ws.close();
wss.close(done);
});
});
});
};
});
wss.on('connection', (ws) => {
ws.on('message', (msg, isBinary) => {
assert.ok(isBinary);
ws.send(msg);
});
});
});
});
describe('SSL', () => {
it('connects to secure websocket server', (done) => {
const server = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const wss = new WebSocket.Server({ server });
wss.on('connection', () => {
server.close(done);
});
server.listen(0, () => {
rejectUnauthorized: false
});
ws.on('open', ws.close);
});
});
it('connects to secure websocket server with client side certificate', (done) => {
const server = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
ca: [fs.readFileSync('test/fixtures/ca-certificate.pem')],
key: fs.readFileSync('test/fixtures/key.pem'),
requestCert: true
});
const wss = new WebSocket.Server({ noServer: true });
server.on('upgrade', (request, socket, head) => {
assert.ok(socket.authorized);
wss.handleUpgrade(request, socket, head, (ws) => {
ws.on('close', (code) => {
assert.strictEqual(code, 1005);
server.close(done);
});
});
});
server.listen(0, () => {
cert: fs.readFileSync('test/fixtures/client-certificate.pem'),
key: fs.readFileSync('test/fixtures/client-key.pem'),
rejectUnauthorized: false
});
ws.on('open', ws.close);
});
});
it('cannot connect to secure websocket server via ws://', (done) => {
const server = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const wss = new WebSocket.Server({ server });
server.listen(0, () => {
rejectUnauthorized: false
});
ws.on('error', () => {
server.close(done);
wss.close();
});
});
});
it('can send and receive text data', (done) => {
const server = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const wss = new WebSocket.Server({ server });
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, Buffer.from('foobar'));
assert.ok(!isBinary);
server.close(done);
});
});
server.listen(0, () => {
rejectUnauthorized: false
});
ws.on('open', () => {
ws.send('foobar');
ws.close();
});
});
});
it('can send a big binary message', (done) => {
const buf = crypto.randomBytes(5 * 1024 * 1024);
const server = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem')
});
const wss = new WebSocket.Server({ server });
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
assert.ok(isBinary);
ws.send(message);
ws.close();
});
});
server.listen(0, () => {
rejectUnauthorized: false
});
ws.on('open', () => ws.send(buf));
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, buf);
assert.ok(isBinary);
server.close(done);
});
});
}).timeout(4000);
it('allows to disable sending the SNI extension', (done) => {
const original = tls.connect;
tls.connect = (options) => {
assert.strictEqual(options.servername, '');
tls.connect = original;
done();
};
});
it("works around a double 'error' event bug in Node.js", function (done) {
//
// The `minVersion` and `maxVersion` options are not supported in
// Node.js < 10.16.0.
//
if (process.versions.modules < 64) return this.skip();
//
// The `'error'` event can be emitted multiple times by the
// `http.ClientRequest` object in Node.js < 13. This test reproduces the
// issue in Node.js 12.
//
const server = https.createServer({
cert: fs.readFileSync('test/fixtures/certificate.pem'),
key: fs.readFileSync('test/fixtures/key.pem'),
minVersion: 'TLSv1.2'
});
const wss = new WebSocket.Server({ server });
server.listen(0, () => {
maxVersion: 'TLSv1.1',
rejectUnauthorized: false
});
ws.on('error', (err) => {
assert.ok(err instanceof Error);
server.close(done);
wss.close();
});
});
});
});
describe('Request headers', () => {
it('adds the authorization header if the url has userinfo', (done) => {
const agent = new CustomAgent();
const userinfo = 'test:testpass';
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('authorization'),
`Basic ${Buffer.from(userinfo).toString('base64')}`
);
done();
};
});
it('honors the `auth` option', (done) => {
const agent = new CustomAgent();
const auth = 'user:pass';
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('authorization'),
`Basic ${Buffer.from(auth).toString('base64')}`
);
done();
};
});
it('favors the url userinfo over the `auth` option', (done) => {
const agent = new CustomAgent();
const auth = 'foo:bar';
const userinfo = 'baz:qux';
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('authorization'),
`Basic ${Buffer.from(userinfo).toString('base64')}`
);
done();
};
});
it('adds custom headers', (done) => {
const agent = new CustomAgent();
agent.addRequest = (req) => {
assert.strictEqual(req.getHeader('cookie'), 'foo=bar');
done();
};
headers: { Cookie: 'foo=bar' },
agent
});
});
it('excludes default ports from host header', () => {
const options = { lookup() {} };
const variants = [
];
for (const [url, host] of variants) {
const ws = new WebSocket(url, options);
assert.strictEqual(ws._req.getHeader('host'), host);
}
});
it("doesn't add the origin header by default", (done) => {
const agent = new CustomAgent();
agent.addRequest = (req) => {
assert.strictEqual(req.getHeader('origin'), undefined);
done();
};
});
it('honors the `origin` option (1/2)', (done) => {
const agent = new CustomAgent();
agent.addRequest = (req) => {
done();
};
agent
});
});
it('honors the `origin` option (2/2)', (done) => {
const agent = new CustomAgent();
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('sec-websocket-origin'),
);
done();
};
protocolVersion: 8,
agent
});
});
});
describe('permessage-deflate', () => {
it('is enabled by default', (done) => {
const agent = new CustomAgent();
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('sec-websocket-extensions'),
'permessage-deflate; client_max_window_bits'
);
done();
};
});
it('can be disabled', (done) => {
const agent = new CustomAgent();
agent.addRequest = (req) => {
assert.strictEqual(
req.getHeader('sec-websocket-extensions'),
undefined
);
done();
};
perMessageDeflate: false,
agent
});
});
it('can send extension parameters', (done) => {
const agent = new CustomAgent();
const value =
'permessage-deflate; server_no_context_takeover;' +
' client_no_context_takeover; server_max_window_bits=10;' +
' client_max_window_bits';
agent.addRequest = (req) => {
assert.strictEqual(req.getHeader('sec-websocket-extensions'), value);
done();
};
perMessageDeflate: {
clientNoContextTakeover: true,
serverNoContextTakeover: true,
clientMaxWindowBits: true,
serverMaxWindowBits: 10
},
agent
});
});
it('consumes all received data when connection is closed (1/2)', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: { threshold: 0 },
port: 0
},
() => {
const messages = [];
ws.on('open', () => {
ws._socket.on('close', () => {
assert.strictEqual(ws._receiver._state, 5);
});
});
ws.on('message', (message, isBinary) => {
assert.ok(!isBinary);
messages.push(message.toString());
});
ws.on('close', (code) => {
assert.strictEqual(code, 1006);
assert.deepStrictEqual(messages, ['foo', 'bar', 'baz', 'qux']);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
ws.send('foo');
ws.send('bar');
ws.send('baz');
ws.send('qux', () => ws._socket.end());
});
});
it('consumes all received data when connection is closed (2/2)', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
const messageLengths = [];
ws.on('open', () => {
ws._socket.prependListener('close', () => {
assert.strictEqual(ws._receiver._state, 5);
assert.strictEqual(ws._socket._readableState.length, 3);
});
const push = ws._socket.push;
// Override `ws._socket.push()` to know exactly when data is
// received and call `ws.terminate()` immediately after that without
// relying on a timer.
ws._socket.push = (data) => {
ws._socket.push = push;
ws._socket.push(data);
ws.terminate();
};
const payload1 = Buffer.alloc(15 * 1024);
const payload2 = Buffer.alloc(1);
const opts = {
fin: true,
opcode: 0x02,
mask: false,
readOnly: false
};
const list = [
...Sender.frame(payload1, { rsv1: false, ...opts }),
...Sender.frame(payload2, { rsv1: true, ...opts })
];
for (let i = 0; i < 399; i++) {
list.push(list[list.length - 2], list[list.length - 1]);
}
// This hack is used because there is no guarantee that more than
// 16 KiB will be sent as a single TCP packet.
push.call(ws._socket, Buffer.concat(list));
wss.clients
.values()
.next()
.value.send(payload2, { compress: false });
});
ws.on('message', (message, isBinary) => {
assert.ok(isBinary);
messageLengths.push(message.length);
});
ws.on('close', (code) => {
assert.strictEqual(code, 1006);
assert.strictEqual(messageLengths.length, 402);
assert.strictEqual(messageLengths[0], 15360);
assert.strictEqual(messageLengths[messageLengths.length - 1], 1);
wss.close(done);
});
}
);
});
it('handles a close frame received while compressing data', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws._receiver.on('conclude', () => {
assert.ok(ws._sender._deflating);
});
ws.send('foo');
ws.send('bar');
ws.send('baz');
ws.send('qux');
});
}
);
wss.on('connection', (ws) => {
const messages = [];
ws.on('message', (message, isBinary) => {
assert.ok(!isBinary);
messages.push(message.toString());
});
ws.on('close', (code, reason) => {
assert.deepStrictEqual(messages, ['foo', 'bar', 'baz', 'qux']);
assert.strictEqual(code, 1000);
assert.deepStrictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
ws.close(1000);
});
});
describe('#close', () => {
it('can be used while data is being decompressed', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
const messages = [];
ws.on('open', () => {
ws._socket.on('end', () => {
assert.strictEqual(ws._receiver._state, 5);
});
});
ws.on('message', (message, isBinary) => {
assert.ok(!isBinary);
if (messages.push(message.toString()) > 1) return;
ws.close(1000);
});
ws.on('close', (code, reason) => {
assert.deepStrictEqual(messages, ['', '', '', '']);
assert.strictEqual(code, 1000);
assert.deepStrictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
const buf = Buffer.from('c10100c10100c10100c10100', 'hex');
ws._socket.write(buf);
});
});
});
describe('#send', () => {
it('can send text data', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: { threshold: 0 },
port: 0
},
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws.send('hi', { compress: true });
ws.close();
});
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, Buffer.from('hi'));
assert.ok(!isBinary);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
ws.send(message, { binary: isBinary, compress: true });
});
});
});
it('can send a `TypedArray`', (done) => {
const array = new Float32Array(5);
for (let i = 0; i < array.length; i++) {
array[i] = i / 2;
}
const wss = new WebSocket.Server(
{
perMessageDeflate: { threshold: 0 },
port: 0
},
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws.send(array, { compress: true });
ws.close();
});
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, Buffer.from(array.buffer));
assert.ok(isBinary);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
assert.ok(isBinary);
ws.send(message, { compress: true });
});
});
});
it('can send an `ArrayBuffer`', (done) => {
const array = new Float32Array(5);
for (let i = 0; i < array.length; i++) {
array[i] = i / 2;
}
const wss = new WebSocket.Server(
{
perMessageDeflate: { threshold: 0 },
port: 0
},
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws.send(array.buffer, { compress: true });
ws.close();
});
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, Buffer.from(array.buffer));
assert.ok(isBinary);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
assert.ok(isBinary);
ws.send(message, { compress: true });
});
});
});
it('ignores the `compress` option if the extension is disabled', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
perMessageDeflate: false
});
ws.on('open', () => {
ws.send('hi', { compress: true });
ws.close();
});
ws.on('message', (message, isBinary) => {
assert.deepStrictEqual(message, Buffer.from('hi'));
assert.ok(!isBinary);
wss.close(done);
});
});
wss.on('connection', (ws) => {
ws.on('message', (message, isBinary) => {
ws.send(message, { binary: isBinary, compress: true });
});
});
});
it('calls the callback if the socket is closed prematurely', (done) => {
const called = [];
const wss = new WebSocket.Server(
{ perMessageDeflate: true, port: 0 },
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws.send('foo');
ws.send('bar', (err) => {
called.push(1);
assert.strictEqual(ws.readyState, WebSocket.CLOSING);
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'The socket was closed while data was being compressed'
);
});
ws.send('baz');
ws.send('qux', (err) => {
called.push(2);
assert.strictEqual(ws.readyState, WebSocket.CLOSING);
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'The socket was closed while data was being compressed'
);
});
});
}
);
wss.on('connection', (ws) => {
ws.on('close', () => {
assert.deepStrictEqual(called, [1, 2]);
wss.close(done);
});
ws._socket.end();
});
});
});
describe('#terminate', () => {
it('can be used while data is being compressed', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: { threshold: 0 },
port: 0
},
() => {
perMessageDeflate: { threshold: 0 }
});
ws.on('open', () => {
ws.send('hi', (err) => {
assert.strictEqual(ws.readyState, WebSocket.CLOSING);
assert.ok(err instanceof Error);
assert.strictEqual(
err.message,
'The socket was closed while data was being compressed'
);
ws.on('close', () => {
wss.close(done);
});
});
ws.terminate();
});
}
);
});
it('can be used while data is being decompressed', (done) => {
const wss = new WebSocket.Server(
{
perMessageDeflate: true,
port: 0
},
() => {
const messages = [];
ws.on('message', (message, isBinary) => {
assert.ok(!isBinary);
if (messages.push(message.toString()) > 1) return;
process.nextTick(() => {
assert.strictEqual(ws._receiver._state, 5);
ws.terminate();
});
});
ws.on('close', (code, reason) => {
assert.deepStrictEqual(messages, ['', '', '', '']);
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
}
);
wss.on('connection', (ws) => {
const buf = Buffer.from('c10100c10100c10100c10100', 'hex');
ws._socket.write(buf);
});
});
});
});
describe('Connection close', () => {
it('closes cleanly after simultaneous errors (1/2)', (done) => {
let clientCloseEventEmitted = false;
let serverClientCloseEventEmitted = false;
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(err.code, 'WS_ERR_INVALID_OPCODE');
assert.strictEqual(
err.message,
'Invalid WebSocket frame: invalid opcode 5'
);
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
clientCloseEventEmitted = true;
if (serverClientCloseEventEmitted) wss.close(done);
});
});
ws.on('open', () => {
// Write an invalid frame in both directions to trigger simultaneous
// failure.
const chunk = Buffer.from([0x85, 0x00]);
wss.clients.values().next().value._socket.write(chunk);
ws._socket.write(chunk);
});
});
wss.on('connection', (ws) => {
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(err.code, 'WS_ERR_INVALID_OPCODE');
assert.strictEqual(
err.message,
'Invalid WebSocket frame: invalid opcode 5'
);
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
serverClientCloseEventEmitted = true;
if (clientCloseEventEmitted) wss.close(done);
});
});
});
});
it('closes cleanly after simultaneous errors (2/2)', (done) => {
let clientCloseEventEmitted = false;
let serverClientCloseEventEmitted = false;
const wss = new WebSocket.Server({ port: 0 }, () => {
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(err.code, 'WS_ERR_INVALID_OPCODE');
assert.strictEqual(
err.message,
'Invalid WebSocket frame: invalid opcode 5'
);
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
clientCloseEventEmitted = true;
if (serverClientCloseEventEmitted) wss.close(done);
});
});
ws.on('open', () => {
// Write an invalid frame in both directions and change the
// `readyState` to `WebSocket.CLOSING`.
const chunk = Buffer.from([0x85, 0x00]);
const serverWs = wss.clients.values().next().value;
serverWs._socket.write(chunk);
serverWs.close();
ws._socket.write(chunk);
ws.close();
});
});
wss.on('connection', (ws) => {
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(err.code, 'WS_ERR_INVALID_OPCODE');
assert.strictEqual(
err.message,
'Invalid WebSocket frame: invalid opcode 5'
);
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
serverClientCloseEventEmitted = true;
if (clientCloseEventEmitted) wss.close(done);
});
});
});
});
it('resumes the socket when an error occurs', (done) => {
const maxPayload = 16 * 1024;
const wss = new WebSocket.Server({ maxPayload, port: 0 }, () => {
});
wss.on('connection', (ws) => {
const list = [
...Sender.frame(Buffer.alloc(maxPayload + 1), {
fin: true,
opcode: 0x02,
mask: true,
readOnly: false
})
];
ws.on('error', (err) => {
assert.ok(err instanceof RangeError);
assert.strictEqual(err.code, 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH');
assert.strictEqual(err.message, 'Max payload size exceeded');
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1006);
assert.strictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
});
ws._socket.push(Buffer.concat(list));
});
});
it('resumes the socket when the close frame is received', (done) => {
const wss = new WebSocket.Server({ port: 0 }, () => {
});
wss.on('connection', (ws) => {
const opts = { fin: true, mask: true, readOnly: false };
const list = [
...Sender.frame(Buffer.alloc(16 * 1024), { opcode: 0x02, ...opts }),
...Sender.frame(EMPTY_BUFFER, { opcode: 0x08, ...opts })
];
ws.on('close', (code, reason) => {
assert.strictEqual(code, 1005);
assert.strictEqual(reason, EMPTY_BUFFER);
wss.close(done);
});
ws._socket.push(Buffer.concat(list));
});
});
});
});