aboutsummaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/js/bun/websocket/websocket-server.test.ts292
-rw-r--r--test/js/web/websocket/websocket.test.js34
2 files changed, 208 insertions, 118 deletions
diff --git a/test/js/bun/websocket/websocket-server.test.ts b/test/js/bun/websocket/websocket-server.test.ts
index 2c2352f91..7913147f9 100644
--- a/test/js/bun/websocket/websocket-server.test.ts
+++ b/test/js/bun/websocket/websocket-server.test.ts
@@ -3,6 +3,77 @@ import { gcTick } from "harness";
import { serve, ServerWebSocket } from "bun";
describe("websocket server", () => {
+ it("send & receive empty messages", done => {
+ const serverReceived: any[] = [];
+ const clientReceived: any[] = [];
+ var clientDone = false;
+ var serverDone = false;
+
+ let server = Bun.serve({
+ websocket: {
+ open(ws) {
+ ws.send("");
+ ws.send(new ArrayBuffer(0));
+ },
+ message(ws, data) {
+ serverReceived.push(data);
+
+ if (serverReceived.length === 2) {
+ if (serverReceived.find(d => d === "") === undefined) {
+ done(new Error("expected empty string"));
+ }
+
+ if (!serverReceived.find(d => d.byteLength === 0)) {
+ done(new Error("expected empty Buffer"));
+ }
+
+ serverDone = true;
+
+ if (clientDone && serverDone) {
+ z.close();
+ server.stop(true);
+ done();
+ }
+ }
+ },
+ close() {},
+ },
+ fetch(req, server) {
+ if (!server.upgrade(req)) {
+ return new Response(null, { status: 404 });
+ }
+ },
+ port: 0,
+ });
+
+ let z = new WebSocket(`ws://${server.hostname}:${server.port}`);
+ z.onmessage = e => {
+ clientReceived.push(e.data);
+
+ if (clientReceived.length === 2) {
+ if (clientReceived.find(d => d === "") === undefined) {
+ done(new Error("expected empty string"));
+ }
+
+ if (!clientReceived.find(d => d.byteLength === 0)) {
+ done(new Error("expected empty Buffer"));
+ }
+
+ clientDone = true;
+ if (clientDone && serverDone) {
+ server.stop(true);
+ z.close();
+
+ done();
+ }
+ }
+ };
+ z.addEventListener("open", () => {
+ z.send("");
+ z.send(new Buffer(0));
+ });
+ });
+
it("remoteAddress works", done => {
let server = Bun.serve({
websocket: {
@@ -859,16 +930,13 @@ describe("websocket server", () => {
const server = serve({
port: 0,
websocket: {
- open(ws) {
- server.stop();
- },
+ open(ws) {},
message(ws, msg) {
ws.send(sendQueue[serverCounter++] + " ");
- gcTick();
+ serverCounter % 10 === 0 && gcTick();
},
},
fetch(req, server) {
- server.stop();
if (
server.upgrade(req, {
data: { count: 0 },
@@ -879,32 +947,39 @@ describe("websocket server", () => {
return new Response("noooooo hello world");
},
});
+ try {
+ await new Promise<void>((resolve, reject) => {
+ const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
+ websocket.onerror = e => {
+ reject(e);
+ };
- await new Promise<void>((resolve, reject) => {
- const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
- websocket.onerror = e => {
- reject(e);
- };
+ websocket.onopen = () => {
+ server.stop();
+ websocket.send("first");
+ };
- var counter = 0;
- websocket.onopen = () => websocket.send("first");
- websocket.onmessage = e => {
- try {
- const expected = sendQueue[clientCounter++] + " ";
- expect(e.data).toBe(expected);
- websocket.send("next");
- if (clientCounter === sendQueue.length) {
+ websocket.onmessage = e => {
+ try {
+ const expected = sendQueue[clientCounter++] + " ";
+ expect(e.data).toBe(expected);
+ websocket.send("next");
+ if (clientCounter === sendQueue.length) {
+ websocket.close();
+ resolve();
+ }
+ } catch (r) {
+ reject(r);
+ console.error(r);
websocket.close();
- resolve();
}
- } catch (r) {
- reject(r);
- console.error(r);
- websocket.close();
- }
- };
- });
- server.stop(true);
+ };
+ });
+ } catch (e) {
+ throw e;
+ } finally {
+ server.stop(true);
+ }
});
// this test sends 100 messages to 10 connected clients via pubsub
@@ -913,20 +988,15 @@ describe("websocket server", () => {
var sendQueue: any[] = [];
for (var i = 0; i < 100; i++) {
sendQueue.push(ropey + " " + i);
- gcTick();
}
+
var serverCounter = 0;
var clientCount = 0;
const server = serve({
port: 0,
websocket: {
- // FIXME: update this test to not rely on publishToSelf: true,
- publishToSelf: true,
-
open(ws) {
- server.stop();
ws.subscribe("test");
- gcTick();
if (!ws.isSubscribed("test")) {
throw new Error("not subscribed");
}
@@ -936,15 +1006,15 @@ describe("websocket server", () => {
}
ws.subscribe("test");
clientCount++;
- if (clientCount === 10) setTimeout(() => ws.publish("test", "hello world"), 1);
+ if (clientCount === 10) {
+ setTimeout(() => server.publish("test", "hello world"), 1);
+ }
},
message(ws, msg) {
- if (serverCounter < sendQueue.length) ws.publish("test", sendQueue[serverCounter++] + " ");
+ if (serverCounter < sendQueue.length) server.publish("test", sendQueue[serverCounter++] + " ");
},
},
fetch(req) {
- gcTick();
- server.stop();
if (
server.upgrade(req, {
data: { count: 0 },
@@ -954,89 +1024,89 @@ describe("websocket server", () => {
return new Response("noooooo hello world");
},
});
+ try {
+ const connections = new Array(10);
+ const websockets = new Array(connections.length);
+ var doneCounter = 0;
+ await new Promise<void>(done => {
+ for (var i = 0; i < connections.length; i++) {
+ var j = i;
+ var resolve: (_?: unknown) => void,
+ reject: (_?: unknown) => void,
+ resolveConnection: (_?: unknown) => void,
+ rejectConnection: (_?: unknown) => void;
+ connections[j] = new Promise((res, rej) => {
+ resolveConnection = res;
+ rejectConnection = rej;
+ });
+ websockets[j] = new Promise((res, rej) => {
+ resolve = res;
+ reject = rej;
+ });
+ const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
+ websocket.onerror = e => {
+ reject(e);
+ };
+ websocket.onclose = () => {
+ doneCounter++;
+ if (doneCounter === connections.length) {
+ done();
+ }
+ };
+ var hasOpened = false;
+ websocket.onopen = () => {
+ if (!hasOpened) {
+ hasOpened = true;
+ resolve(websocket);
+ }
+ };
- const connections = new Array(10);
- const websockets = new Array(connections.length);
- var doneCounter = 0;
- await new Promise<void>(done => {
- for (var i = 0; i < connections.length; i++) {
- var j = i;
- var resolve: (_?: unknown) => void,
- reject: (_?: unknown) => void,
- resolveConnection: (_?: unknown) => void,
- rejectConnection: (_?: unknown) => void;
- connections[j] = new Promise((res, rej) => {
- resolveConnection = res;
- rejectConnection = rej;
- });
- websockets[j] = new Promise((res, rej) => {
- resolve = res;
- reject = rej;
- });
- gcTick();
- const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
- websocket.onerror = e => {
- reject(e);
- };
- websocket.onclose = () => {
- doneCounter++;
- if (doneCounter === connections.length) {
- done();
- }
- };
- var hasOpened = false;
- websocket.onopen = () => {
- if (!hasOpened) {
- hasOpened = true;
- resolve(websocket);
- }
- };
-
- let clientCounter = -1;
- var hasSentThisTick = false;
-
- websocket.onmessage = e => {
- gcTick();
-
- if (!hasOpened) {
- hasOpened = true;
- resolve(websocket);
- }
+ let clientCounter = -1;
+ var hasSentThisTick = false;
- if (e.data === "hello world") {
- clientCounter = 0;
- websocket.send("first");
- return;
- }
+ websocket.onmessage = e => {
+ if (!hasOpened) {
+ hasOpened = true;
+ resolve(websocket);
+ }
- try {
- expect(!!sendQueue.find(a => a + " " === e.data)).toBe(true);
-
- if (!hasSentThisTick) {
- websocket.send("second");
- hasSentThisTick = true;
- queueMicrotask(() => {
- hasSentThisTick = false;
- });
+ if (e.data === "hello world") {
+ clientCounter = 0;
+ websocket.send("first");
+ return;
}
- gcTick();
+ try {
+ expect(!!sendQueue.find(a => a + " " === e.data)).toBe(true);
+
+ if (!hasSentThisTick) {
+ websocket.send("second");
+ hasSentThisTick = true;
+ queueMicrotask(() => {
+ hasSentThisTick = false;
+ });
+ }
- if (clientCounter++ === sendQueue.length - 1) {
+ if (clientCounter++ === sendQueue.length - 1) {
+ websocket.close();
+ resolveConnection();
+ }
+ } catch (r) {
+ console.error(r);
websocket.close();
- resolveConnection();
+ rejectConnection(r);
}
- } catch (r) {
- console.error(r);
- websocket.close();
- rejectConnection(r);
- gcTick();
- }
- };
- }
- });
+ };
+ }
+ });
+ } catch (e) {
+ throw e;
+ } finally {
+ server.stop(true);
+ gcTick();
+ }
+
expect(serverCounter).toBe(sendQueue.length);
- server.stop(true);
}, 30_000);
it("can close with reason and code #2631", done => {
let timeout: any;
diff --git a/test/js/web/websocket/websocket.test.js b/test/js/web/websocket/websocket.test.js
index 867b86123..76ff16ecb 100644
--- a/test/js/web/websocket/websocket.test.js
+++ b/test/js/web/websocket/websocket.test.js
@@ -6,16 +6,33 @@ const TEST_WEBSOCKET_HOST = process.env.TEST_WEBSOCKET_HOST || "wss://ws.postman
describe("WebSocket", () => {
it("should connect", async () => {
- const ws = new WebSocket(TEST_WEBSOCKET_HOST);
- await new Promise((resolve, reject) => {
+ const server = Bun.serve({
+ port: 0,
+ fetch(req, server) {
+ if (server.upgrade(req)) {
+ server.stop();
+ return;
+ }
+
+ return new Response();
+ },
+ websocket: {
+ open(ws) {},
+ message(ws) {
+ ws.close();
+ },
+ },
+ });
+ const ws = new WebSocket(`ws://${server.hostname}:${server.port}`, {});
+ await new Promise(resolve => {
ws.onopen = resolve;
- ws.onerror = reject;
});
- var closed = new Promise((resolve, reject) => {
+ var closed = new Promise(resolve => {
ws.onclose = resolve;
});
ws.close();
await closed;
+ server.stop(true);
});
it("should connect over https", async () => {
@@ -59,17 +76,18 @@ describe("WebSocket", () => {
const server = Bun.serve({
port: 0,
fetch(req, server) {
- server.stop();
done();
+ server.stop();
return new Response();
},
websocket: {
- open(ws) {
+ open(ws) {},
+ message(ws) {
ws.close();
},
},
});
- const ws = new WebSocket(`http://${server.hostname}:${server.port}`, {});
+ new WebSocket(`http://${server.hostname}:${server.port}`, {});
});
describe("nodebuffer", () => {
it("should support 'nodebuffer' binaryType", done => {
@@ -93,6 +111,7 @@ describe("WebSocket", () => {
expect(ws.binaryType).toBe("nodebuffer");
Bun.gc(true);
ws.onmessage = ({ data }) => {
+ ws.close();
expect(Buffer.isBuffer(data)).toBe(true);
expect(data).toEqual(new Uint8Array([1, 2, 3]));
server.stop(true);
@@ -117,6 +136,7 @@ describe("WebSocket", () => {
ws.sendBinary(new Uint8Array([1, 2, 3]));
setTimeout(() => {
client.onmessage = ({ data }) => {
+ client.close();
expect(Buffer.isBuffer(data)).toBe(true);
expect(data).toEqual(new Uint8Array([1, 2, 3]));
server.stop(true);
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-17 06:16:07 +0000