vitest-websocket-mock 0.1.2 → 0.2.0

package/LICENSE

@@ -1,27 +1,5 @@
-Copyright 2023 Akiomi Kamakura
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-The major part of vitest-websocket-mock implementation is based on jest-webosocket-mock, which is subject to the same license.
-Here is the original copyright notice for jest-webosocket-mock:
-
 Copyright 2018 Romain Bertrand
+Copyright 2023 Akiomi Kamakura
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -8,13 +8,11 @@ A set of utilities and Vitest matchers to help testing complex websocket interac
 A patched fork of [romgain/jest-websocket-mock](https://github.com/romgain/jest-websocket-mock).
 
 **Examples:**
-~~Several examples are provided in the [examples folder](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/).
-In particular:~~
+Several examples are provided in the [examples folder](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/).
+In particular:
 
-NOTE: These examples are currently not working :cry:
-
-- [testing a redux saga that manages a websocket connection](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/redux-saga/src/__tests__/saga.test.js)
-- [testing a component using the saga above](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/redux-saga/src/__tests__/App.test.js)
+- [testing a redux saga that manages a websocket connection](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/redux-saga/src/__tests__/saga.test.ts)
+- [testing a component using the saga above](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/redux-saga/src/__tests__/App.test.tsx)
 - [testing a component that manages a websocket connection using react hooks](https://github.com/akiomik/vitest-websocket-mock/blob/main/examples/hooks/src/App.test.tsx)
 
 ## Install
@@ -292,7 +290,7 @@ afterEach(() => {
 
 ## Known issues
 
-`mock-socket` has a strong usage of delays (`setTimeout` to be more specific). This means using `vitest.useFakeTimers();` will cause issues such as the client appearing to never connect to the server.
+`mock-socket` has a strong usage of delays (`setTimeout` to be more specific). This means using `vi.useFakeTimers();` will cause issues such as the client appearing to never connect to the server.
 
 While running the websocket server from tests within the vitest-dom environment (as opposed to node)
 you may see errors of the nature:
@@ -343,8 +341,6 @@ restrict yourself to the browser APIs!
 
 ## Examples
 
-~~For a real life example, see the
+For a real life example, see the
 [examples directory](https://github.com/akiomik/vitest-websocket-mock/tree/main/examples),
-and in particular the saga tests.~~
-
-NOTE: These examples are currently not working :cry:
+and in particular the saga tests.

package/dist/index.d.ts

@@ -20,9 +20,6 @@ interface WSOptions extends ServerOptions {
     jsonProtocol?: boolean;
 }
 type DeserializedMessage<TMessage = object> = string | TMessage;
-interface MockWebSocket extends Omit<Client, 'close'> {
-    close(options?: CloseOptions): void;
-}
 declare class WS {
     server: Server;
     serializer: (deserializedMessage: DeserializedMessage) => string;
@@ -37,7 +34,7 @@ declare class WS {
     get connected(): Promise<Client>;
     get closed(): Promise<void>;
     get nextMessage(): Promise<unknown>;
-    on(eventName: 'connection' | 'message' | 'close', callback: (socket: MockWebSocket) => void): void;
+    on(eventName: 'connection' | 'message' | 'close', callback: (socket: Client) => void): void;
     send(message: DeserializedMessage): void;
     close(options?: CloseOptions): void;
     error(options?: CloseOptions): void;

package/dist/index.js

@@ -71,7 +71,8 @@ var WS = class _WS {
     const { jsonProtocol = false, ...serverOptions } = opts;
     this.serializer = jsonProtocol ? JSON.stringify : identity;
     this.deserializer = jsonProtocol ? JSON.parse : identity;
-    let connectionResolver, closedResolver;
+    let connectionResolver;
+    let closedResolver;
     this._isConnected = new Promise((done) => connectionResolver = done);
     this._isClosed = new Promise((done) => closedResolver = done);
     this.server = new Server(url, serverOptions);
@@ -136,7 +137,7 @@ var WS = class _WS {
 
 // src/matchers.ts
 var WAIT_DELAY = 1e3;
-var TIMEOUT = Symbol("timoeut");
+var TIMEOUT = Symbol("timeout");
 var makeInvalidWsMessage = function makeInvalidWsMessage2(ws, matcher) {
   return this.utils.matcherHint(this.isNot ? `.not.${matcher}` : `.${matcher}`, "WS", "expected") + `
 
@@ -144,14 +145,14 @@ Expected the websocket object to be a valid WS mock.
 Received: ${typeof ws}
   ${this.utils.printReceived(ws)}`;
 };
-expect.extend({
-  async toReceiveMessage(ws, expected, options) {
+var deriveToReceiveMessage = (name, fn) => {
+  return async function(ws, expected, options) {
     const isWS = ws instanceof WS;
     if (!isWS) {
       return {
         pass: this.isNot,
         // always fail
-        message: makeInvalidWsMessage.bind(this, ws, "toReceiveMessage")
+        message: makeInvalidWsMessage.bind(this, ws, name)
       };
     }
     const waitDelay = options?.timeout ?? WAIT_DELAY;
@@ -163,22 +164,28 @@ expect.extend({
       return {
         pass: this.isNot,
         // always fail
-        message: () => this.utils.matcherHint(this.isNot ? ".not.toReceiveMessage" : ".toReceiveMessage", "WS", "expected") + `
+        message: () => this.utils.matcherHint(`${this.isNot ? ".not" : ""}.${name}`, "WS", "expected") + `
 
 Expected the websocket server to receive a message,
 but it didn't receive anything in ${waitDelay}ms.`
       };
+    } else {
+      const received = messageOrTimeout;
+      const result = await Promise.resolve(fn.call(this, received, expected, options));
+      return { name, ...result };
     }
-    const received = messageOrTimeout;
-    const pass = this.equals(received, expected);
-    const message = pass ? () => this.utils.matcherHint(".not.toReceiveMessage", "WS", "expected") + `
+  };
+};
+var toReceiveMessage = deriveToReceiveMessage("toReceiveMessage", function(received, expected) {
+  const pass = this.equals(received, expected);
+  const message = pass ? () => this.utils.matcherHint(".not.toReceiveMessage", "WS", "expected") + `
 
 Expected the next received message to not equal:
   ${this.utils.printExpected(expected)}
 Received:
   ${this.utils.printReceived(received)}` : () => {
-      const diffString = diff(expected, received, { expand: this.expand });
-      return this.utils.matcherHint(".toReceiveMessage", "WS", "expected") + `
+    const diffString = diff(expected, received, { expand: this.expand });
+    return this.utils.matcherHint(".toReceiveMessage", "WS", "expected") + `
 
 Expected the next received message to equal:
   ${this.utils.printExpected(expected)}
@@ -188,54 +195,64 @@ Received:
 Difference:
 
 ${diffString}`;
-    };
-    return {
-      actual: received,
-      expected,
-      message,
-      name: "toReceiveMessage",
-      pass
-    };
-  },
-  toHaveReceivedMessages(ws, messages) {
+  };
+  return {
+    actual: received,
+    expected,
+    message,
+    pass
+  };
+});
+var deriveToHaveReceivedMessage = (name, fn) => {
+  return function(ws, expected, options) {
     const isWS = ws instanceof WS;
     if (!isWS) {
       return {
         pass: this.isNot,
         // always fail
-        message: makeInvalidWsMessage.bind(this, ws, "toHaveReceivedMessages")
+        message: makeInvalidWsMessage.bind(this, ws, name)
       };
     }
-    const received = messages.map(
-      (expected) => (
+    const result = fn.call(this, ws.messages, expected, options);
+    return { name, ...result };
+  };
+};
+var toHaveReceivedMessages = deriveToHaveReceivedMessage(
+  "toHaveReceivedMessages",
+  function(received, expected) {
+    const equalities = expected.map(
+      (expectedMsg) => (
         // object comparison to handle JSON protocols
-        ws.messages.some((actual) => this.equals(actual, expected))
+        received.some((receivedMsg) => this.equals(receivedMsg, expectedMsg))
       )
     );
-    const pass = this.isNot ? received.some(Boolean) : received.every(Boolean);
+    const pass = this.isNot ? equalities.some(Boolean) : equalities.every(Boolean);
     const message = pass ? () => this.utils.matcherHint(".not.toHaveReceivedMessages", "WS", "expected") + `
 
 Expected the WS server to not have received the following messages:
-  ${this.utils.printExpected(messages)}
+  ${this.utils.printExpected(expected)}
 But it received:
-  ${this.utils.printReceived(ws.messages)}` : () => {
+  ${this.utils.printReceived(received)}` : () => {
       return this.utils.matcherHint(".toHaveReceivedMessages", "WS", "expected") + `
 
 Expected the WS server to have received the following messages:
-  ${this.utils.printExpected(messages)}
+  ${this.utils.printExpected(expected)}
 Received:
-  ${this.utils.printReceived(ws.messages)}
+  ${this.utils.printReceived(received)}
 
 `;
     };
     return {
-      actual: ws.messages,
-      expected: messages,
+      actual: received,
+      expected,
       message,
-      name: "toHaveReceivedMessages",
       pass
     };
   }
+);
+expect.extend({
+  toReceiveMessage,
+  toHaveReceivedMessages
 });
 export {
   WS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-websocket-mock",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Mock websockets and assert complex websocket interactions with Vitest",
   "type": "module",
   "repository": {
@@ -34,26 +34,28 @@
   "author": "Akiomi Kamakura",
   "license": "MIT",
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "@vitest/coverage-c8": "^0.32.2",
-    "eslint": "^8.28.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.0",
+    "@typescript-eslint/parser": "^5.59.0",
+    "@vitest/coverage-v8": "^0.32.2",
+    "eslint": "^8.38.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-config-react-app": "^7.0.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.3.4",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "prettier": "^2.0.2",
     "rimraf": "^4.1.2",
     "tsup": "^7.0.0",
     "typescript": "^4.0.2",
     "vite": "^4.3.9",
-    "vitest": "^0.31.0"
+    "vitest": "^0.32.0"
   },
   "peerDependencies": {
-    "vitest": "^0.31.0"
+    "vitest": "^0.32.0"
   },
   "dependencies": {
     "jest-diff": "^29.2.0",
-    "mock-socket": "^9.1.0"
+    "mock-socket": "^9.2.1"
   },
   "files": [
     "dist",