insomnia/packages/insomnia-test/flows/web-socket-request.flow.ts

import { ContextMenuItem } from "@package/enums/context-menu-items";
import { TreeNodeType } from "@package/enums/tree-node-types";
import { DEFAULT_TIMEOUT } from "@package/misc/constants";
import { step } from "@package/misc/step";
import type { RequestAuthentication } from "@package/models/authentication";
import type { Collection } from "@package/models/collection";
import type { Folder } from "@package/models/folder";
import type { ResponseView } from "@package/models/response";
import type {
  WebSocketRequestBody} from "@package/models/websocket-request";
import {
  WebSocketRequest
} from "@package/models/websocket-request";
import type { WebSocketRequestPage } from "@package/pages/web-socket-request.page";

import { BaseFlow } from "./base.flow";

export class WebSocketRequestFlow extends BaseFlow {
  /**
   * Creates a new WebSocket request under `parent`, naming it via the
   * rename flow and applying its fields on the request page.
   */
  @step()
  async create(
    parent: Collection | Folder,
    request: WebSocketRequest,
  ): Promise<WebSocketRequest> {
    const workspace = this.pageManager.workspacePage;
    const node = await workspace.resolveNode(parent);
    await workspace.rightClick(node);
    await workspace.clickContextMenu(ContextMenuItem.WebSocketRequest);

    const requestNode = await workspace.waitForFirstRealChild(node._id);
    await workspace.rightClick(requestNode);
    await workspace.clickContextMenu(ContextMenuItem.Rename);
    await workspace.setItemName(request.name);
    await workspace.clickRename();

    const webSocketRequestPage = this.pageManager.webSocketRequestPage;
    await webSocketRequestPage.navigate();
    await this.applyRequestFields(
      webSocketRequestPage,
      request,
      requestNode._id,
    );

    return this.assertCreated(await this.get(request.name), request.name);
  }

  /**
   * Closes the WebSocket connection for `request`, invoking `callback`
   * once the disconnect completes (or after `timeout` ms elapses), and
   * returns the resulting response, locating it via the standalone
   * project tree.
   */
  @step()
  async disconnect(
    request: WebSocketRequest,
    callback: () => Promise<void> | void = () => {},
    timeout = DEFAULT_TIMEOUT,
  ): Promise<ResponseView> {
    const workspace = this.pageManager.workspacePage;
    const webSocketRequestPage = this.pageManager.webSocketRequestPage;
    const responsePage = this.pageManager.responsePage;

    const node = await workspace.requireItemNode(request, TreeNodeType.Request);
    await workspace.openRequestNode(node);
    await webSocketRequestPage.navigate();

    await webSocketRequestPage.disconnect(callback, timeout);
    await responsePage.navigate();

    const data = await responsePage.get();
    return data;
  }

  /**
   * Reads back an existing request's fields by name or identity via the
   * standalone project tree.
   */
  @step()
  async get(
    item: string | { name: string; id?: string },
    parent?: Collection,
  ): Promise<WebSocketRequest | undefined> {
    const identity = typeof item === "string" ? { name: item } : item;
    const workspace = this.pageManager.workspacePage;
    const webSocketRequestPage = this.pageManager.webSocketRequestPage;

    const node = await workspace.findItemNode(identity, TreeNodeType.Request);
    if (!node) return undefined;

    await workspace.openRequestNode(node);
    await webSocketRequestPage.navigate();

    const data = await webSocketRequestPage.get();
    return new WebSocketRequest({ name: identity.name, id: node._id, ...data });
  }

  /**
   * Opens the WebSocket connection for `request` and returns the
   * resulting response, locating it via the standalone project tree.
   */
  @step()
  async send(
    request: WebSocketRequest,
    options?: { expectConnected?: boolean },
  ): Promise<ResponseView> {
    const workspace = this.pageManager.workspacePage;
    const webSocketRequestPage = this.pageManager.webSocketRequestPage;
    const responsePage = this.pageManager.responsePage;

    const node = await workspace.requireItemNode(request, TreeNodeType.Request);
    await workspace.openRequestNode(node);
    await webSocketRequestPage.navigate();

    await webSocketRequestPage.connect(options);
    await responsePage.navigate();

    const data = await responsePage.get();
    return data;
  }

  /**
   * Opens `request` and applies `authentication` on its Auth tab.
   */
  @step()
  async setAuthentication(
    request: WebSocketRequest,
    authentication: RequestAuthentication,
  ): Promise<void> {
    const workspace = this.pageManager.workspacePage;
    const page = this.pageManager.webSocketRequestPage;

    const node = await workspace.requireItemNode(request, TreeNodeType.Request);
    await workspace.openRequestNode(node);
    await page.navigate();
    await this.applyAuthentication(page.auth, authentication);
  }

  /**
   * Sends `body` as a message over the request's open WebSocket
   * connection, invoking `callback` once the send completes (or after
   * `timeout` ms elapses), and returns the resulting response, locating it
   * via the standalone project tree.
   */
  @step()
  async sendMessage(
    request: WebSocketRequest,
    body: WebSocketRequestBody,
    callback: () => Promise<void> | void = () => {},
    timeout = DEFAULT_TIMEOUT,
  ): Promise<ResponseView> {
    const workspace = this.pageManager.workspacePage;
    const webSocketRequestPage = this.pageManager.webSocketRequestPage;
    const responsePage = this.pageManager.responsePage;

    const node = await workspace.requireItemNode(request, TreeNodeType.Request);
    await workspace.openRequestNode(node);
    await webSocketRequestPage.navigate();

    await webSocketRequestPage.sendMessage(body, callback, timeout);
    await responsePage.navigate();

    const data = await responsePage.get();
    return data;
  }

  private async applyRequestFields(
    page: WebSocketRequestPage,
    request: WebSocketRequest,
    id: string,
  ): Promise<void> {
    await page.setUrl(request.url);
    await this.waitForUrlPersisted("insomnia.WebSocketRequest.db", page, id, request.url);
    if (request.params && request.params.length > 0) {
      await page.setParams(request.params);
    }
    if (request.headers && request.headers.length > 0) {
      await page.setHeaders(request.headers);
    }
    if (request.authentication) {
      await this.applyAuthentication(page.auth, request.authentication);
    }
    if (request.body) {
      await page.setBody(request.body);
    }
  }
}