vitest-websocket-mock 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,7 +1,65 @@
+import { Server, Client, CloseOptions, ServerOptions } from 'mock-socket';
+
 /**
  * @copyright Romain Bertrand 2018
  */
-import './matchers';
-export { default } from './websocket';
-export { default as WS } from './websocket';
-//# sourceMappingURL=index.d.ts.map
+declare class Queue<ItemT> {
+    pendingItems: Array<ItemT>;
+    nextItemResolver: () => void;
+    nextItem: Promise<void>;
+    put(item: ItemT): void;
+    get(): Promise<ItemT>;
+}
+
+/**
+ * @copyright Romain Bertrand 2018
+ * @copyright Akiomi Kamakura 2023
+ */
+
+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;
+    deserializer: (message: string) => DeserializedMessage;
+    static instances: Array<WS>;
+    messages: Array<DeserializedMessage>;
+    messagesToConsume: Queue<unknown>;
+    private _isConnected;
+    private _isClosed;
+    static clean(): void;
+    constructor(url: string, opts?: WSOptions);
+    get connected(): Promise<Client>;
+    get closed(): Promise<void>;
+    get nextMessage(): Promise<unknown>;
+    on(eventName: 'connection' | 'message' | 'close', callback: (socket: MockWebSocket) => void): void;
+    send(message: DeserializedMessage): void;
+    close(options?: CloseOptions): void;
+    error(options?: CloseOptions): void;
+}
+
+/**
+ * @copyright Romain Bertrand 2018
+ * @copyright Akiomi Kamakura 2023
+ */
+
+type ReceiveMessageOptions = {
+    timeout?: number;
+};
+interface CustomMatchers<R = unknown> {
+    toReceiveMessage<TMessage = object>(message: DeserializedMessage<TMessage>, options?: ReceiveMessageOptions): Promise<R>;
+    toHaveReceivedMessages<TMessage = object>(messages: Array<DeserializedMessage<TMessage>>): R;
+}
+declare module 'vitest' {
+    interface Assertion<T = any> extends CustomMatchers<T> {
+    }
+    interface AsymmetricMatchersContaining extends CustomMatchers {
+    }
+}
+
+export { WS, WS as default };

package/dist/index.js

@@ -0,0 +1,243 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/matchers.ts
+import { diff } from "jest-diff";
+import { expect } from "vitest";
+
+// src/websocket.ts
+import { Server } from "mock-socket";
+
+// src/act-compat.ts
+var act;
+try {
+  act = __require("@testing-library/react").act;
+} catch (_) {
+  act = (callback) => {
+    callback();
+  };
+}
+var act_compat_default = act;
+
+// src/queue.ts
+var Queue = class {
+  pendingItems = [];
+  nextItemResolver;
+  nextItem = new Promise((done) => this.nextItemResolver = done);
+  put(item) {
+    this.pendingItems.push(item);
+    this.nextItemResolver();
+    this.nextItem = new Promise((done) => this.nextItemResolver = done);
+  }
+  get() {
+    const item = this.pendingItems.shift();
+    if (item) {
+      return Promise.resolve(item);
+    }
+    let resolver;
+    const nextItemPromise = new Promise((done) => resolver = done);
+    this.nextItem.then(() => {
+      resolver(this.pendingItems.shift());
+    });
+    return nextItemPromise;
+  }
+};
+
+// src/websocket.ts
+var identity = (x) => x;
+var WS = class _WS {
+  server;
+  serializer;
+  deserializer;
+  static instances = [];
+  messages = [];
+  messagesToConsume = new Queue();
+  _isConnected;
+  _isClosed;
+  static clean() {
+    _WS.instances.forEach((instance) => {
+      instance.close();
+      instance.messages = [];
+    });
+    _WS.instances = [];
+  }
+  constructor(url, opts = {}) {
+    _WS.instances.push(this);
+    const { jsonProtocol = false, ...serverOptions } = opts;
+    this.serializer = jsonProtocol ? JSON.stringify : identity;
+    this.deserializer = jsonProtocol ? JSON.parse : identity;
+    let connectionResolver, closedResolver;
+    this._isConnected = new Promise((done) => connectionResolver = done);
+    this._isClosed = new Promise((done) => closedResolver = done);
+    this.server = new Server(url, serverOptions);
+    this.server.on("close", closedResolver);
+    this.server.on("connection", (socket) => {
+      connectionResolver(socket);
+      socket.on("message", (message) => {
+        const parsedMessage = this.deserializer(message);
+        this.messages.push(parsedMessage);
+        this.messagesToConsume.put(parsedMessage);
+      });
+    });
+  }
+  get connected() {
+    let resolve;
+    const connectedPromise = new Promise((done) => resolve = done);
+    const waitForConnected = async () => {
+      await act_compat_default(async () => {
+        await this._isConnected;
+      });
+      resolve(await this._isConnected);
+    };
+    waitForConnected();
+    return connectedPromise;
+  }
+  get closed() {
+    let resolve;
+    const closedPromise = new Promise((done) => resolve = done);
+    const waitForclosed = async () => {
+      await act_compat_default(async () => {
+        await this._isClosed;
+      });
+      await this._isClosed;
+      resolve();
+    };
+    waitForclosed();
+    return closedPromise;
+  }
+  get nextMessage() {
+    return this.messagesToConsume.get();
+  }
+  on(eventName, callback) {
+    this.server.on(eventName, callback);
+  }
+  send(message) {
+    act_compat_default(() => {
+      this.server.emit("message", this.serializer(message));
+    });
+  }
+  close(options) {
+    act_compat_default(() => {
+      this.server.close(options);
+    });
+  }
+  error(options) {
+    act_compat_default(() => {
+      this.server.emit("error", null);
+    });
+    this.server.close(options);
+  }
+};
+
+// src/matchers.ts
+var WAIT_DELAY = 1e3;
+var TIMEOUT = Symbol("timoeut");
+var makeInvalidWsMessage = function makeInvalidWsMessage2(ws, matcher) {
+  return this.utils.matcherHint(this.isNot ? `.not.${matcher}` : `.${matcher}`, "WS", "expected") + `
+
+Expected the websocket object to be a valid WS mock.
+Received: ${typeof ws}
+  ${this.utils.printReceived(ws)}`;
+};
+expect.extend({
+  async toReceiveMessage(ws, expected, options) {
+    const isWS = ws instanceof WS;
+    if (!isWS) {
+      return {
+        pass: this.isNot,
+        // always fail
+        message: makeInvalidWsMessage.bind(this, ws, "toReceiveMessage")
+      };
+    }
+    const waitDelay = options?.timeout ?? WAIT_DELAY;
+    const messageOrTimeout = await Promise.race([
+      ws.nextMessage,
+      new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), waitDelay))
+    ]);
+    if (messageOrTimeout === TIMEOUT) {
+      return {
+        pass: this.isNot,
+        // always fail
+        message: () => this.utils.matcherHint(this.isNot ? ".not.toReceiveMessage" : ".toReceiveMessage", "WS", "expected") + `
+
+Expected the websocket server to receive a message,
+but it didn't receive anything in ${waitDelay}ms.`
+      };
+    }
+    const received = messageOrTimeout;
+    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") + `
+
+Expected the next received message to equal:
+  ${this.utils.printExpected(expected)}
+Received:
+  ${this.utils.printReceived(received)}
+
+Difference:
+
+${diffString}`;
+    };
+    return {
+      actual: received,
+      expected,
+      message,
+      name: "toReceiveMessage",
+      pass
+    };
+  },
+  toHaveReceivedMessages(ws, messages) {
+    const isWS = ws instanceof WS;
+    if (!isWS) {
+      return {
+        pass: this.isNot,
+        // always fail
+        message: makeInvalidWsMessage.bind(this, ws, "toHaveReceivedMessages")
+      };
+    }
+    const received = messages.map(
+      (expected) => (
+        // object comparison to handle JSON protocols
+        ws.messages.some((actual) => this.equals(actual, expected))
+      )
+    );
+    const pass = this.isNot ? received.some(Boolean) : received.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)}
+But it received:
+  ${this.utils.printReceived(ws.messages)}` : () => {
+      return this.utils.matcherHint(".toHaveReceivedMessages", "WS", "expected") + `
+
+Expected the WS server to have received the following messages:
+  ${this.utils.printExpected(messages)}
+Received:
+  ${this.utils.printReceived(ws.messages)}
+
+`;
+    };
+    return {
+      actual: ws.messages,
+      expected: messages,
+      message,
+      name: "toHaveReceivedMessages",
+      pass
+    };
+  }
+});
+export {
+  WS,
+  WS as default
+};

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "vitest-websocket-mock",
-  "version": "0.1.0",
-  "description": "Mock websockets and assert complex websocket interactions with Jest",
+  "version": "0.1.2",
+  "description": "Mock websockets and assert complex websocket interactions with Vitest",
   "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/akiomik/vitest-websocket-mock.git"
   },
   "types": "dist/index.d.ts",
-  "module": "dist/index.es.js",
+  "module": "dist/index.js",
   "exports": {
     ".": {
-      "import": "dist/index.es.js",
-      "types": "dist/index.d.ts"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     }
   },
   "scripts": {
     "clean": "rimraf dist",
     "prebuild": "npm run clean",
-    "build": "vite build && tsc -p tsconfig.build.json",
+    "build": "tsup",
     "lint": "prettier --check . && eslint .",
     "format": "prettier --write .",
     "prepublishOnly": "npm run build",
@@ -43,9 +43,9 @@
     "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",
-    "vite-plugin-node-stdlib-browser": "^0.2.1",
     "vitest": "^0.31.0"
   },
   "peerDependencies": {

package/dist/act-compat.d.ts

@@ -1,16 +0,0 @@
-/**
- * @copyright Romain Bertrand 2018
- * @copyright Akiomi Kamakura 2023
- *
- * A simple compatibility method for react's "act".
- * If @testing-library/react is already installed, we just use
- * their implementation - it's complete and has useful warnings.
- * If @testing-library/react is *not* installed, then we just assume
- * that the user is not testing a react application, and use a noop instead.
- */
-type Callback = () => Promise<void | undefined> | void | undefined;
-type AsyncAct = (callback: Callback) => Promise<undefined>;
-type SyncAct = (callback: Callback) => void;
-declare let act: AsyncAct | SyncAct;
-export default act;
-//# sourceMappingURL=act-compat.d.ts.map

package/dist/act-compat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"act-compat.d.ts","sourceRoot":"","sources":["../src/act-compat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,KAAK,QAAQ,GAAG,MAAM,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;AACnE,KAAK,QAAQ,GAAG,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;AAC3D,KAAK,OAAO,GAAG,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;AAE5C,QAAA,IAAI,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC;AAW5B,eAAe,GAAG,CAAC"}