websocket-ts 1.1.1 → 2.1.1

package/test/buffer/timebuffer.test.ts

@@ -1,115 +0,0 @@
-import {TimeBuffer} from "../../src";
-import {createEmptyArray, createSequentialArray} from "./common";
-
-describe("Testsuite for TimeBuffer", () => {
-    const maxAge = 1000;
-    let tb: TimeBuffer<number>;
-
-    beforeEach(() => {
-        tb = new TimeBuffer<number>(maxAge); // no older than 1000 ms
-    });
-
-    test("TimeBuffer length", async () => {
-        expect(tb.len()).toBe(0);
-        for (let i = 0; i < 10; i++) {
-            expect(tb.write([i])).toBe(1);
-            expect(tb.len()).toBe(i + 1);
-        }
-
-        await delay(maxAge + 500).then(() => {
-            expect(tb.len()).toBe(0);
-        });
-    });
-
-    test("TimeBuffer capacity", () => {
-        expect(tb.cap()).toBe(Number.POSITIVE_INFINITY);
-    });
-
-    test("TimeBuffer elements should expire when they reach their maxAge", async () => {
-        // add 10 items
-        for (let i = 0; i < 10; i++) {
-            expect(tb.write([i])).toBe(1);
-            expect(tb.len()).toBe(i + 1);
-        }
-
-        // give elements some time to "age"
-        await delay(500).then(() => {
-
-            // all items should still be in range
-            expect(tb.len()).toBe(10);
-
-            // add 10 more items
-            for (let i = 0; i < 5; i++) {
-                expect(tb.write([i])).toBe(1);
-                expect(tb.len()).toBe(10 + i + 1);
-            }
-        });
-
-        // the first 10 items should now be removed, there are 5 items remaining
-        await delay(800).then(() => {
-            expect(tb.len()).toBe(5);
-        });
-    });
-
-    test("TimeBuffer read should return items up to maxAge ", async () => {
-        const w1 = createSequentialArray(10);
-        expect(tb.write(w1)).toBe(10);
-        const r1 = createEmptyArray(10);
-        expect(tb.read(r1)).toBe(10);
-        for (let i = 0; i < 10; i++)
-            expect(w1[i]).toBe(r1[i]);
-
-        await delay(500).then(() => {
-            const r2 = createEmptyArray(10);
-            expect(tb.read(r2)).toBe(10);
-            for (let i = 0; i < 10; i++)
-                expect(w1[i]).toBe(r2[i]);
-
-            const w2 = createSequentialArray(5);
-            expect(tb.write(w2)).toBe(5);
-            const r3 = createEmptyArray(15);
-            expect(tb.read(r3)).toBe(15);
-            for (let i = 0; i < 15; i++)
-                if (i < 10)
-                    expect(r3[i]).toBe(w1[i]);
-                else
-                    expect(r3[i]).toBe(w2[i - 10]);
-        });
-    });
-
-    test("TimeBuffer read on empty should return no item", () => {
-        const r1 = createEmptyArray(10);
-        expect(tb.read(r1)).toBe(0);
-        expect(tb.read([])).toBe(0);
-    });
-
-    test("TimeBuffer forEach() should only be invoked on valid items", async () => {
-        const w1 = createSequentialArray(10);
-        expect(tb.write(w1)).toBe(10);
-        const r2 = [] as number[];
-        tb.forEach(e => r2.push(e));
-        expect(r2.length).toBe(10);
-
-        await delay(500).then(() => {
-            const w2 = createSequentialArray(5);
-            expect(tb.write(w2)).toBe(5);
-            const r3 = [] as number[]
-            tb.forEach(e => r3.push(e));
-            expect(r3.length).toBe(15);
-        });
-
-        await delay(800).then(() => {
-            const r4 = [] as number[];
-            tb.forEach(e => r4.push(e));
-            expect(r4.length).toBe(5);
-        })
-    })
-});
-
-function delay(ms: number): Promise<void> {
-    return new Promise<void>(resolve => {
-        setTimeout(() => {
-            resolve();
-        }, ms);
-    })
-}

package/test/websocket.test.ts

@@ -1,341 +0,0 @@
-import {ConstantBackoff, LRUBuffer, Websocket, WebsocketBuilder, WebsocketEvents} from "../src";
-import {Server} from "ws";
-
-describe("Testsuite for Websocket", () => {
-    const port = 42421;
-    const url = `ws://localhost:${port}`;
-
-    let ws: Websocket | undefined;
-    let wss: Server | undefined;
-
-    type WsInstanceWithEvent<K extends Event> = { instance: Websocket, event: K };
-
-    beforeEach(async () => {
-        await startServer(port).then(server => {
-            wss = server;
-        });
-    });
-
-    afterEach(async () => {
-        if (ws !== undefined)
-            await shutdownClientOrTimeout(ws, 100);
-        if (wss !== undefined)
-            await shutdownServerOrTimeout(wss, 100);
-    });
-
-    test("Websocket should fire onOpen-event when connection is established", async () => {
-        await new Promise<WsInstanceWithEvent<Event>>(resolve => {
-            ws = new WebsocketBuilder(url).onOpen((instance, event) => {
-                resolve({instance, event});
-            }).build();
-        }).then(e => {
-            expect(e.instance).toBe(ws);
-            expect(e.event.type).toBe(WebsocketEvents.open);
-            expect(e.instance.underlyingWebsocket?.readyState).toBe(WebSocket.OPEN);
-        });
-    });
-
-    test("Websocket should fire onClose-event when the server closes the connection", async () => {
-        await new Promise<WsInstanceWithEvent<CloseEvent>>(resolve => {
-            ws = new WebsocketBuilder(url)
-                .onClose((instance, event) => {
-                    resolve({instance, event});
-                }).build();
-            wss?.close(); // close server
-        }).then(e => {
-            expect(e.instance).toBe(ws);
-            expect(e.event.type).toBe(WebsocketEvents.close);
-            expect(e.instance.underlyingWebsocket?.readyState).toBe(WebSocket.CLOSED);
-        });
-    });
-
-    test("Websocket should fire onClose-event when the client closes the connection", async () => {
-        const closeCode = 1000;
-        const closeReason = "client closed the connection";
-
-        await new Promise<WsInstanceWithEvent<CloseEvent>>(resolve => {
-            ws = new WebsocketBuilder(url)
-                .onOpen((instance, _) => {
-                    instance.close(closeCode, closeReason); // close client
-                })
-                .onClose((instance, event) => {
-                    resolve({instance, event});
-                }).build();
-        }).then(e => {
-            expect(e.instance).toBe(ws);
-            expect(e.event.type).toBe(WebsocketEvents.close);
-            expect(e.event.code).toBe(closeCode);
-            expect(e.event.reason).toBe(closeReason);
-            expect(e.instance.underlyingWebsocket?.readyState).toBe(WebSocket.CLOSED);
-        });
-    });
-
-    test("Websocket should fire onError-event when the server refuses the connection", async () => {
-        await new Promise<WsInstanceWithEvent<Event>>(resolve => {
-            wss?.close(); // close server
-            ws = new WebsocketBuilder(url)
-                .onError((instance, event) => {
-                    resolve({instance, event});
-                }).build();
-        }).then(e => {
-            expect(e.instance).toBe(ws);
-            expect(e.event.type).toBe(WebsocketEvents.error);
-            expect(e.instance.underlyingWebsocket?.readyState).toBe(WebSocket.CLOSED);
-        });
-    });
-
-    test("Websocket should fire onMessage-event when a message is received", async () => {
-        const testMessage = "this is a test message.";
-        const onMessagePromise = new Promise<WsInstanceWithEvent<MessageEvent>>(resolve => {
-            ws = new WebsocketBuilder(url)
-                .onMessage((instance, event) => {
-                    resolve({instance, event});
-                }).build();
-        }).then(e => {
-            expect(e.instance).toBe(ws);
-            expect(e.event.type).toBe(WebsocketEvents.message);
-            expect(e.event.data).toBe(testMessage);
-            expect(e.instance.underlyingWebsocket?.readyState).toBe(WebSocket.OPEN);
-        });
-
-        // wait for the client to connect to the server and then send a message to the client
-        if (wss !== undefined) {
-            await onClientConnected(wss).then(client => {
-                client.send(testMessage);
-            })
-        }
-
-        // wait for the client to receive the message, it should fire the 'onMessage'-event
-        await onMessagePromise;
-    });
-
-    test("Websocket should send messages when connected", async () => {
-        const testMessage = "this is a test message.";
-        const onConnectAndSendPromise = new Promise<void>(resolve => {
-            ws = new WebsocketBuilder(url)
-                .onOpen((instance, _) => {
-                    instance.send(testMessage); // send message as soon as we are connected
-                    resolve();
-                }).build();
-        });
-        const onReceivePromise = new Promise<string>(resolve => {
-            wss?.on('connection', socket => {
-                socket.onmessage = me => {
-                    resolve(me.data.toString());
-                }
-            });
-        });
-
-        await onConnectAndSendPromise;  // wait for client to connect and send the message
-        await onReceivePromise.then(actual => { // wait for server to receive the message and compare
-            expect(actual).toBe(testMessage);
-        })
-    });
-
-    test("Websocket should ignore send()-calls when the connection was closed by the user", async () => {
-        const testMessage = "this is a test message.";
-        await new Promise<void>(resolve => { // connect to server
-            ws = new WebsocketBuilder(url)
-                .onOpen((instance, _) => {
-                    resolve();
-                }).build();
-        });
-
-        // monkey-patch the underlying websockets send()-method, to see if it is still called
-        let messagesSent = 0;
-        if (ws !== undefined && ws.underlyingWebsocket !== undefined) {
-            ws.underlyingWebsocket.send = (_: string | ArrayBufferLike | Blob | ArrayBufferView) => {
-                messagesSent++;
-            }
-        }
-
-        ws?.close(); // close connection from client-side
-        expect(ws!['closedByUser']).toBe(true);  // should indicate that the connection was closed by user
-        ws?.send(testMessage);
-        expect(messagesSent).toBe(0); // should still be 0 since send() was never really called
-    });
-
-    test("Websocket should send buffered messages when the connection is (re-)established", async () => {
-        const testMessages = ["one", "two", "three"];
-
-        let onOpen: () => void;
-        let onClose: () => void;
-        let wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        const wsOnClosePromise = new Promise<void>(resolve => onClose = resolve);
-        ws = new WebsocketBuilder(url)
-            .withBuffer(new LRUBuffer<string>(10))
-            .withBackoff(new ConstantBackoff(100))
-            .onOpen(() => onOpen())
-            .onClose(() => onClose())
-            .build();
-
-        await wsOnOpenPromise; // wait for client to be connected
-        if (wss !== undefined)  // shutdown the server
-            await shutdownServerOrTimeout(wss, 100);
-        await wsOnClosePromise; // wait for client to register the disconnect
-
-        // sending messages while disconnected should be buffered
-        expect((ws!['buffer'] as LRUBuffer<string>).len()).toBe(0);
-        testMessages.forEach(msg => ws?.send(msg));
-        expect((ws!['buffer'] as LRUBuffer<string>).len()).toBe(testMessages.length);
-
-        // re-start the server and create promise for when all messages are received
-        let onMessagesReceived: (msg: string[]) => void;
-        const onMessagesReceivedPromise = new Promise<string[]>(resolve => onMessagesReceived = resolve);
-        await startServer(port).then(server => {
-            wss = server;
-            wss.on('connection', socket => {
-                let buf = [] as string[];
-                socket.onmessage = me => {
-                    buf.push(me.data.toString());
-                    if (buf.length === testMessages.length)
-                        onMessagesReceived(buf);
-                }
-            })
-        });
-
-        // wait for the client to re-connect, it should send out all pending messages...
-        wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        await wsOnOpenPromise;
-
-        // ...which are then received by the server in correct order...
-        await onMessagesReceivedPromise.then(actual => {
-            expect(actual).toEqual(testMessages);
-        })
-
-        // ...after which the clients message-buffer should be empty again
-        expect((ws!['buffer'] as LRUBuffer<string>).len()).toBe(0);
-    });
-
-    test("Websocket should remove event-listener correctly when removeEventListener() is called", async () => {
-        let count = 0;
-        const openEventListener = () => count++; // increment counter on every connect
-        let onOpen: () => void;
-        let onClose: () => void;
-        let wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        const wsOnClosePromise = new Promise<void>(resolve => onClose = resolve);
-        ws = new WebsocketBuilder(url)
-            .withBackoff(new ConstantBackoff(100))
-            .onOpen(() => onOpen())
-            .onOpen(openEventListener)
-            .onClose(() => onClose())
-            .build();
-        await wsOnOpenPromise; // wait for initial connection
-        expect(count).toBe(1); // openEventListener should be called exactly once at this point
-        ws.removeEventListener(WebsocketEvents.open, openEventListener); // unregister the event-handler
-        if (wss !== undefined)  // shutdown the server
-            await shutdownServerOrTimeout(wss, 100);
-        await wsOnClosePromise; // wait for client to register the disconnect
-
-        // restart the server and wait for the client to connect
-        await startServer(port).then(server => wss = server);
-        wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        await wsOnOpenPromise;
-        expect(count).toBe(1); // count should still be 1, since the incrementing event-handler was unregistered
-    });
-
-    test("Websocket should remove event-listeners if they declare the 'once'-property as true", async () => {
-        let count = 0;
-        const openEventListener = () => count++; // increment counter on every connect
-        let onOpen: () => void;
-        let onClose: () => void;
-        let wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        const wsOnClosePromise = new Promise<void>(resolve => onClose = resolve);
-        ws = new WebsocketBuilder(url)
-            .withBackoff(new ConstantBackoff(100))
-            .onOpen(() => onOpen())
-            .onOpen(openEventListener, {once: true} as AddEventListenerOptions) // declare 'once'-property
-            .onClose(() => onClose())
-            .build();
-        await wsOnOpenPromise; // wait for initial connection
-        expect(count).toBe(1); // openEventListener should be called exactly once at this point
-        if (wss !== undefined)  // shutdown the server
-            await shutdownServerOrTimeout(wss, 100);
-        await wsOnClosePromise; // wait for client to register the disconnect
-
-        // restart the server and wait for the client to connect
-        await startServer(port).then(server => wss = server);
-        wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        await wsOnOpenPromise;
-        expect(count).toBe(1); // count should still be 1, since the incrementing event-handler was unregistered
-    });
-
-    test("Websocket should try to reconnect when the connection is lost", async () => {
-
-    });
-
-    test("Websocket should fire retryEvent when trying to reconnect", async () => {
-        let retryCount = 0;
-        let onOpen: () => void;
-        let onClose: () => void;
-        let onRetry: () => void;
-        let wsOnOpenPromise = new Promise<void>(resolve => onOpen = resolve);
-        const wsOnClosePromise = new Promise<void>(resolve => onClose = resolve);
-        let wsOnRetryPromise = new Promise<void>(resolve => onRetry = resolve);
-        ws = new WebsocketBuilder(url)
-            .withBackoff(new ConstantBackoff(100)) // 100ms between retries
-            .onOpen(() => onOpen())
-            .onClose(() => onClose())
-            .onRetry(() => retryCount++)
-            .onRetry(() => onRetry())
-            .build();
-        await wsOnOpenPromise;
-        if (wss !== undefined)  // shutdown the server
-            await shutdownServerOrTimeout(wss, 100);
-        await wsOnClosePromise; // wait for client to register the disconnect
-        await wsOnRetryPromise; // it should retry after 100ms and this will trigger the event
-        await delay(450); // after 450 more ms, it should've triggered another 4 times
-        expect(retryCount >= 3 || retryCount <= 6).toBeTruthy();
-    });
-});
-
-function delay(ms: number): Promise<void> {
-    return new Promise<void>(resolve => {
-        setTimeout(() => {
-            resolve();
-        }, ms);
-    })
-}
-
-function startServer(port: number): Promise<Server> {
-    return new Promise(resolve => {
-        const wss = new Server({port});
-        wss.on('listening', () => {
-            resolve(wss);
-        });
-    });
-}
-
-function shutdownServerOrTimeout(wss: Server, timeout: number) {
-    let timeoutPromise = delay(timeout);
-    let shutdownServerPromise = shutdownServer(wss);
-    return Promise.race([timeoutPromise, shutdownServerPromise]);
-}
-
-function shutdownServer(wss: Server): Promise<void> {
-    return new Promise<void>(resolve => {
-        wss.addListener("close", () => resolve());
-        wss.close();
-    });
-}
-
-function shutdownClientOrTimeout(ws: Websocket, timeout: number) {
-    let timeoutPromise = delay(timeout);
-    let shutdownClientPromise = shutdownClient(ws);
-    return Promise.race([timeoutPromise, shutdownClientPromise]);
-}
-
-function shutdownClient(ws: Websocket): Promise<void> {
-    return new Promise<void>(resolve => {
-        ws.addEventListener(WebsocketEvents.close, () => resolve());
-        ws.close();
-    });
-}
-
-function onClientConnected(wss: Server): Promise<WebSocket> {
-    return new Promise(resolve => {
-        wss.on('connection', (client: WebSocket) => {
-            resolve(client);
-        });
-    });
-}

package/test/websocketBuilder.test.ts

@@ -1,36 +0,0 @@
-import {WebsocketBuilder, LRUBuffer, ConstantBackoff} from "../src";
-
-describe("Testsuite for WebsocketBuilder", () => {
-    const url = "ws://localhost:42421";
-
-    test("WebsocketBuilder should set protocols", () => {
-        const sut = new WebsocketBuilder(url);
-        const expected = ["p1", "p2", "p3"];
-        sut.withProtocols(expected);
-        const actual = sut['protocols'];
-        expect(actual).toEqual(expected);
-    });
-
-    test("WebsocketBuilder should set backoff", () => {
-        const sut = new WebsocketBuilder(url);
-        const expected = new ConstantBackoff(100);
-        sut.withBackoff(expected);
-        const actual = sut['backoff'];
-        expect(actual).toBe(expected);
-    });
-
-    test("WebsocketBuilder should set buffer", () => {
-        const sut = new WebsocketBuilder(url);
-        const expected = new LRUBuffer(10);
-        sut.withBuffer(expected);
-        const actual = sut['buffer'];
-        expect(actual).toBe(expected);
-    });
-
-    test("WebsocketBuilder should return the same instance on every build()-call", () => {
-        const sut = new WebsocketBuilder(url);
-        const ws = sut.build();
-        const ws2 = sut.build();
-        expect(ws).toBe(ws2);
-    });
-});