What is the best way to ensure that Jest waits for an event to occur before performing an assertion?

Question

What is the best way to ensure that Jest waits for an event to occur before performing an assertion?

I've developed a facade for the nats streaming lib in the following way:

import nats, { Message, Stan, Subscription, SubscriptionOptions } from 'node-nats-streaming'

class NatsHelper {
  private client: Stan | null = null

  public connect(url: string, clusterID: string, clientID: string, listener: (...args: any[]) => void, verboseConnection: boolean = true): void {
    const clientIDString = `${clientID}-${randomBytes(4).toString('hex')}`
    if (verboseConnection) {
      console.log(`Connecting to NATS cluster '${clusterID}' with clientID '${clientIDString}' on url '${url}'`)
    }
    const connectionAttempt = nats.connect(
      clusterID,
      clientIDString,
      {
        url
      }
    )

    const setupConnection = (...args: any[]): void => {
      this.client = connectionAttempt

      this.client.on('close', (): void => {
        if (verboseConnection) {
          console.log(`Connection with NATS cluster '${clusterID}' with clientID '${clientIDString}' on url '${url}' was closed`)
        }
        this.client = null
        process.exit()
      })

      process.on('SIGINT', () => this.client?.close())
      process.on('SIGTERM', () => this.client?.close())

      if (verboseConnection) {
        console.log(`Connected to NATS cluster '${clusterID}' with clientID '${clientIDString}' on url '${url}' successfuly`)
      }
      listener(...args)
    }

    connectionAttempt.on('connect', setupConnection)
  }
}

However, I am encountering an issue where I cannot verify if the provided listener function is being called because it depends on the Stan 'connect' event, which Jest completes the test before it occurs.

Is there a way for Jest to wait for this event to occur and then execute the expect function?

javascript typescript events jestjs ts-jest

Answer 1

Answer №1

It seems like you may have made this more complex than necessary. You can actually write a test for the original code without making any changes by using mocking in Jest to mock out the library and provide mock implementations for your on method. Check out the example below:

import nats from "node-nats-streaming";
import { mock } from "jest-mock-extended";
import { NatsHelper } from "./nats";

jest.mock("node-nats-streaming");

describe("NatsHelper", () => {
  it("calls listener on connectEvent", () => {
    const client = mock<nats.Stan>();

    client.on.mockImplementation((name, callback) => {
      if (name !== "close") {
        callback();
      }
      return client;
    });

    jest.mocked(nats).connect.mockReturnValue(client);

    const connector = new NatsHelper();

    const listener = jest.fn();

    connector.connect("foo", "foo", "foo", listener);

    expect(listener).toHaveBeenCalled();
  });
});

Answer 2

It seems like you may have made this more complex than necessary. You can actually write a test for the original code without making any changes by using mocking in Jest to mock out the library and provide mock implementations for your on method. Check out the example below:

import nats from "node-nats-streaming";
import { mock } from "jest-mock-extended";
import { NatsHelper } from "./nats";

jest.mock("node-nats-streaming");

describe("NatsHelper", () => {
  it("calls listener on connectEvent", () => {
    const client = mock<nats.Stan>();

    client.on.mockImplementation((name, callback) => {
      if (name !== "close") {
        callback();
      }
      return client;
    });

    jest.mocked(nats).connect.mockReturnValue(client);

    const connector = new NatsHelper();

    const listener = jest.fn();

    connector.connect("foo", "foo", "foo", listener);

    expect(listener).toHaveBeenCalled();
  });
});

Answer 3

Answer №2

[UPDATE] Discovered a solution that addresses my query. It turns out we have the ability to "transform" an event into a Promise, like so:

import { randomBytes } from 'crypto'
import nats from 'node-nats-streaming'

export class NullClientError extends Error {
  constructor() {
    super('Nats client is not connected')
    this.name = 'NullClientError'
  }
}

export class NatsHelper {
  private verboseConnectionString: string
  private client: nats.Stan
  private connector: nats.Stan

  constructor(
    private readonly verboseConnection: boolean = true
  ) { }

  public async connect(url: string, clusterID: string, clientID: string, callback: (...args: any[]) => void): Promise<void> {
    const clientIDString = `${clientID}-${randomBytes(4).toString('hex')}`
    this.verboseConnectionString = `NATS cluster '${clusterID}' with clientID '${clientIDString}' on url '${url}'`
    if (this.verboseConnection) {
      console.log(`Establishing connection to ${this.verboseConnectionString}`)
    }

    this.connector = nats.connect(
      clusterID,
      clientIDString,
      {
        url
      }
    )

    this.connector.on('connect', (...args: any[]) => {
      const realCallback = this.setupListener(callback)
      realCallback(...args)
    })

    return await new Promise(
      resolve => {
        if (this.connector) {
          this.connector.on('connect', () => {
            resolve()
          })
        }
      }
    )
  }

  private setupListener(listener: (...args: any[]) => void): (...args: any[]) => void {
    const setupConnection = (...args: any[]): void => {
      if (this.connector === undefined) {
        throw new NullClientError()
      }

      this.client = this.connector

      if (this.client === undefined) {
        throw new NullClientError()
      }

      this.client.on('close', (): void => {
        if (this.verboseConnection) {
          console.log(`The connection with ${this.verboseConnectionString} has been terminated`)
        }
        process.exit()
      })

      process.on('SIGINT', () => this.client?.close())
      process.on('SIGTERM', () => this.client?.close())

      if (this.verboseConnection) {
        console.log(`Successfully connected to ${this.verboseConnectionString}`)
      }
      listener(...args)
    }
    return setupConnection
  }
}

To validate it, run asynchronous tests as follows:

describe('NatsHelper', () => {
  test('verify NatsHelper invokes connect with accurate parameters', async () => {
    const connectSpy = jest.spyOn(nats, 'connect')
    const sut = new NatsHelper(false)
    const { url, clusterID, clientID, listener } = makeConnectionParams()
    await sut.connect(url, clusterID, clientID, listener)
    const clientIDString = connectSpy.mock.calls[0][1]
    expect(clientIDString).toContain(clientID)
    expect(connectSpy).toHaveBeenCalledWith(clusterID, clientIDString, { url })
  })

  test('ensure NatsHelper transfers the callback upon successful connection', async () => {
    const connectionParms = makeConnectionParams()
    const { url, clusterID, clientID } = connectionParms
    const listenerSpy = jest.spyOn(connectionParms, 'listener')
    const sut = new NatsHelper(false)
    await sut.connect(url, clusterID, clientID, connectionParms.listener)
    expect(listenerSpy).toHaveBeenCalledTimes(1)
  })
}

Answer 4

[UPDATE] Discovered a solution that addresses my query. It turns out we have the ability to "transform" an event into a Promise, like so:

import { randomBytes } from 'crypto'
import nats from 'node-nats-streaming'

export class NullClientError extends Error {
  constructor() {
    super('Nats client is not connected')
    this.name = 'NullClientError'
  }
}

export class NatsHelper {
  private verboseConnectionString: string
  private client: nats.Stan
  private connector: nats.Stan

  constructor(
    private readonly verboseConnection: boolean = true
  ) { }

  public async connect(url: string, clusterID: string, clientID: string, callback: (...args: any[]) => void): Promise<void> {
    const clientIDString = `${clientID}-${randomBytes(4).toString('hex')}`
    this.verboseConnectionString = `NATS cluster '${clusterID}' with clientID '${clientIDString}' on url '${url}'`
    if (this.verboseConnection) {
      console.log(`Establishing connection to ${this.verboseConnectionString}`)
    }

    this.connector = nats.connect(
      clusterID,
      clientIDString,
      {
        url
      }
    )

    this.connector.on('connect', (...args: any[]) => {
      const realCallback = this.setupListener(callback)
      realCallback(...args)
    })

    return await new Promise(
      resolve => {
        if (this.connector) {
          this.connector.on('connect', () => {
            resolve()
          })
        }
      }
    )
  }

  private setupListener(listener: (...args: any[]) => void): (...args: any[]) => void {
    const setupConnection = (...args: any[]): void => {
      if (this.connector === undefined) {
        throw new NullClientError()
      }

      this.client = this.connector

      if (this.client === undefined) {
        throw new NullClientError()
      }

      this.client.on('close', (): void => {
        if (this.verboseConnection) {
          console.log(`The connection with ${this.verboseConnectionString} has been terminated`)
        }
        process.exit()
      })

      process.on('SIGINT', () => this.client?.close())
      process.on('SIGTERM', () => this.client?.close())

      if (this.verboseConnection) {
        console.log(`Successfully connected to ${this.verboseConnectionString}`)
      }
      listener(...args)
    }
    return setupConnection
  }
}

To validate it, run asynchronous tests as follows:

describe('NatsHelper', () => {
  test('verify NatsHelper invokes connect with accurate parameters', async () => {
    const connectSpy = jest.spyOn(nats, 'connect')
    const sut = new NatsHelper(false)
    const { url, clusterID, clientID, listener } = makeConnectionParams()
    await sut.connect(url, clusterID, clientID, listener)
    const clientIDString = connectSpy.mock.calls[0][1]
    expect(clientIDString).toContain(clientID)
    expect(connectSpy).toHaveBeenCalledWith(clusterID, clientIDString, { url })
  })

  test('ensure NatsHelper transfers the callback upon successful connection', async () => {
    const connectionParms = makeConnectionParams()
    const { url, clusterID, clientID } = connectionParms
    const listenerSpy = jest.spyOn(connectionParms, 'listener')
    const sut = new NatsHelper(false)
    await sut.connect(url, clusterID, clientID, connectionParms.listener)
    expect(listenerSpy).toHaveBeenCalledTimes(1)
  })
}

What is the best way to ensure that Jest waits for an event to occur before performing an assertion?

Answer №1

Answer №2

Similar questions

Automatically updating the user interface with fresh data using Jade, Express.js, and NodeJS

When a hyperlink is clicked, an image appears in the div

Getting the correct JSON field value from a JavaScript Promise object in the right way

Initiate timer when mouse leaves; pause timer upon mouse hovering using JavaScript

Is the jQuery AJAX call using POST method being retrieved as $_GET?

Asking for access to a Node server with React authentication

Is it possible to change a CSS variable using VueJS?

Combining a random selection with a timer in JavaScript for a dynamic user experience

Utilizing browser back functionality to dismiss a layer: A step-by-step guide

Facing a challenge with handling HTTP data in a TypeScript-based Angular web application

Multiple layers of SVG text with consistent widths and dynamic heights

In Java, use an HttpRequest to retrieve the webpage content and ensure that the process waits until the JavaScript has finished

Guide to using prop types with a Typescript function and integrating them with a Material-UI button

Creating a flexible route path with additional query parameters

Why am I unable to use a string as the src in next/image component?

The placeholder text is not displaying with bullets in Internet Explorer. However, it is functioning correctly in Chrome

Establish the focus when the TinyMCE editor loads

Next.js 11 Script integration for TruConversion Heatmap Tracking

Issues with rendering Google Maps on google-maps-react persists, stuck endlessly in loading phase

Is there a better way to handle passing named arguments to a JavaScript Function? Any potential challenges that may arise