如何使用 Jest 测试递归函数被调用 X 次？ 如果我使用间谍方法，我的方法会永远挂起吗？

Question

utils file

const isStatusError = (err: any): err is StatusError =>
  err.status !== undefined;

export const handleError = async (err: any, emailer?: Mailer) => {
  const sendErrorEmail = async (
    subject: string,
    text: string,
    emailer?: Mailer
  ) => {
    try {
      const mail: Pick<Mail, "from" | "to"> = {
        from: config.email.user,
        to: config.email.user,
      };

      // 2. This throws an error
      await emailer?.send({ ...mail, subject, text });
    } catch (err) {
      // 3. It should call this function recursively...
      await handleError(new EmailError(err), emailer);
    }
  };

  if (isStatusError(err)) {
    if (err instanceof ScrapeError) {
      console.log("Failed to scrape the website: \n", err.message);
    }

    if (err instanceof AgendaJobError) {
      console.log("Job ", err.message);
      // @TODO
    }

    if (err instanceof RepositoryError) {
      console.log("Repository: ");
      console.log(err.message);
      // @TODO
    }

    // 4. and eventually come here and end the test...
    if (err instanceof EmailError) {
      console.log("Failed to create email service", err);
    }

    // 1. It goes here first.
    if (err instanceof StatusError) {
      console.log("generic error", err);
      await sendErrorEmail("Error", "", emailer);
    }
  } else {
    if (err instanceof Error) {
      console.log("Generic error", err.message);
    }
    console.log("Generic error", err);
  }
};

test file

import * as utils from "./app.utils";
import { Mailer } from "./services/email/Emailer.types";
import { StatusError } from "./shared/errors";

const getMockEmailer = (implementation?: Partial<Mailer>) =>
  jest.fn<Mailer, []>(() => ({
    service: "gmail",
    port: 5432,
    secure: false,
    auth: {
      user: "user",
      pass: "pass",
    },
    verify: async () => true,
    send: async () => true,
    ...implementation,
  }))();

describe("error handling", () => {
  it("should handle email failed to send", async () => {
    const mockEmailer = getMockEmailer({
      send: async () => {
        throw new Error();
      },
    });

    // This line is the problem. If I comment it out, it's all good.
    const spiedHandleError = jest.spyOn(utils, "handleError");
    // @TODO: Typescript will complain mockEmailer is missing a private JS Class variable (e.g. #transporter) if you remove `as any`.
    await utils.handleError(new StatusError(500, ""), mockEmailer as any);

    expect(spiedHandleError).toBeCalledTimes(2);
  });
});

This test runs forever, and it is because I made handleError a spy function. I tried to import itself and run await utils.handleError(new EmailError(err), emailer) but it still continue to hang.

So what happens is:

1. It throws an Error.
2. It will then figure out it is a StatusError which is a custom error, and it will output the error and call a function to send an email.
3. However, attempting to send an email throws another Error
4. It should then call itself with EmailError
5. It will detect it is an EmailError and only output the error.

Logic wise, there is no infinite loop. In the utils file, if you comment this const spiedHandleError = jest.spyOn(utils, "handleError"); out, the test will be fine.

Is there a way around this somehow?

Answer 1

It's impossible to spy or mock a function that is used in the same module it was defined. This is the limitation of JavaScript, a variable cannot be reached from another scope. This is what happens:

let moduleObj = (() => {
  let foo = () => 'foo';
  let bar = () => foo();

  return { foo, bar };
})();

moduleObj.foo = () => 'fake foo';

moduleObj.foo() // 'fake foo'
moduleObj.bar() // 'foo'

The only way a function can be written to allow this defining and consistently using it as a method on some object like CommonJS exports:

exports.handleError = async (...) => {
  ...
  exports.handleError(...);
  ...
};

This workaround is impractical and incompatible with ES modules. Unless you do that, it's impossible to spy on recursively called function like handleError . There's babel-plugin-rewire hack that allows to do this but it's known to be incompatible with Jest.

A proper testing strategy is to not assert that the function called itself (such assertions may be useful for debugging but nothing more) but assert effects that the recursion causes. In this case this includes console.log calls.

There are no reasons for spyOn to cause infinite loop. With no mock implementation provided, it's just a wrapper around original function. And as explained above, there's no way how it can affect internal handleError calls, so it shouldn't affect the way tested function works.

It's unsafe to spy on utils ES module object because it's read-only by specification and can result in error depending on Jest setup.

Answer 2

I realized it's my own logic that caused the infinite loop. I forgot to add the return statement to each of my if statement.

My spy function now works.

    const spiedHandleError = jest.spyOn(utils, "handleError");
    await utils.handleError({
      err: new StatusError(500, "error"),
      emailer: mockEmailer,
    });

    expect(spiedHandleError).toBeCalledTimes(2);
    expect(spiedHandleError.mock.calls).toEqual([
      [{ err: new StatusError(500, "error"), emailer: mockEmailer }],
      [
        {
          err: new EmailError("failed to send an error report email."),
          emailer: mockEmailer,
        },
      ],
    ]);