vitest-websocket-mock 0.1.3 → 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/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

@@ -137,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") + `
 
@@ -145,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;
@@ -164,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)}
@@ -189,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.3",
+  "version": "0.2.0",
   "description": "Mock websockets and assert complex websocket interactions with Vitest",
   "type": "module",
   "repository": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "jest-diff": "^29.2.0",
-    "mock-socket": "^9.1.0"
+    "mock-socket": "^9.2.1"
   },
   "files": [
     "dist",