Javascript 如何使用JEST测试承诺递归

我用笑话写了一个测试。 我不知道如何开玩笑地测试承诺递归

在此测试中，执行递归的重试函数是测试的目标，直到承诺得到解决

export function retry <T> (fn: () => Promise <T>, limit: number = 5, interval: number = 10): Promise <T> {
  return new Promise ((resolve, reject) => {
    fn ()
      .then (resolve)
      .catch ((error) => {
        setTimeout (async () => {
          // Reject if the upper limit number of retries is exceeded
          if (limit === 1) {
            reject (error);
            return;
          }
          // If it is less than the upper limit number of retries, execute callback processing recursively
          await retry (fn, limit-1, interval);
        }, interval);
      });
  });
}

因此，它在以下错误中失败

Timeout-Async callback was not invoked within the 5000 ms timeout specified by jest.setTimeout.Error:
    > 40 | test ('resolve on the third call', async () => {
         | ^
      41 | const fn = jest
      42 | .fn ()
      43 | .mockRejectedValueOnce (new Error ('Async error'))

---

我认为，在关于这个错误的玩笑中，它是可以管理的。但是，从根本上说，我不知道如何开玩笑地测试promise递归处理。

超时是因为

重试（）中的

处理程序在第二次尝试调用

重试（）时不调用
resolve
；因此，第一个
retry（）
返回一个承诺，该承诺永远不会得到解决或拒绝

将
wait
替换为
resolve（）
可能会有所帮助（并且
setTimeout
中的函数不需要异步）：

可能您的
重试
任务花费的次数太多（例如：
4,9s
），那么您没有足够的时间来执行下一个测试用例

您可以使用
JEST.setTimeout（10000）增加JEST的
timeout

正式文件

我对您的案例的解决方案：

test("resolve on the third call", async () => {
    jest.setTimeout(10000);
    const fn = jest.fn()
      .mockRejectedValueOnce(new Error("Async error"))
      .mockRejectedValueOnce(new Error("Async error"))
      .mockResolvedValue("OK");

    // test reject value
    await expect(fn()).rejects.toEqual(new Error("Async error"));
    await expect(fn()).rejects.toEqual(new Error("Async error"));

    // test resolve
    const result = await fn();
    expect(result).toEqual("OK");

    // call time
    expect(fn).toHaveBeenCalledTimes(3);
  });

非常感谢。你能帮我解决这个问题吗？非常感谢。你能帮我解决这个问题吗？
  .catch ((error) => {
    setTimeout (() => {
      // Reject if the upper limit number of retries is exceeded
      if (limit === 1) {
        reject (error);
        return;
      }
      // If it is less than the upper limit number of retries, execute callback processing recursively
      resolve(retry (fn, limit-1, interval));
    }, interval);

test("resolve on the third call", async () => {
    jest.setTimeout(10000);
    const fn = jest.fn()
      .mockRejectedValueOnce(new Error("Async error"))
      .mockRejectedValueOnce(new Error("Async error"))
      .mockResolvedValue("OK");

    // test reject value
    await expect(fn()).rejects.toEqual(new Error("Async error"));
    await expect(fn()).rejects.toEqual(new Error("Async error"));

    // test resolve
    const result = await fn();
    expect(result).toEqual("OK");

    // call time
    expect(fn).toHaveBeenCalledTimes(3);
  });