我应该避免在 Node js 上的每一个异步/等待中尝试捕获吗？

Question

这是我在单元测试时遇到的一个设计问题。 让我们深入示例：

想象一下：

async function foo() {
    try {
        return apiCall()
    }
    catch (e) {
        throw new CustomError(e);
    } 
}



async function bar() {
    return foo()
}



async function main() {
    try {
        await bar()
    }catch(e) {
        console.error(e)
    }
}

main()

我们在这里看到了什么？唯一没有 try-catch 块的函数是 bar。 但是如果 foo 失败了，它应该被 main catch 捕获。

像这样进行单元测试时

describe('testing bar', () => {
    it('foo should throw', () => {
        foo.mockImplementantion(() => { throw new CustomError('error')});
        bar()
        .then((result) => console.log(result))
        .catch((err) => { exepect(err).toBeInstanceOf(CustomError)}) // this is what we are testing
    })
})

我们看到的输出是控制台中记录了一个未处理的承诺拒绝。

所以，我的问题是……即使我知道 main() 会捕获错误，我是否应该在所有异步函数中使用 try-catch 块？

Answer 1

如果函数能够从错误中恢复、执行日志记录等副作用或重新引发更有意义的错误，则可能需要try..catch。

如果CustomError 比apiCall 可以抛出的错误更可取，那么try..catch 是必要的，否则不会。 foo 的问题还在于它只处理同步错误。为了处理被拒绝的promise，它应该是return await apiCall()，这是async的一个已知陷阱。

未捕获的拒绝是不受欢迎的，它们目前会导致 UnhandledPromiseRejectionWarning 并且预计会在未来的版本中使 Node 崩溃。最好在顶层以有意义的方式处理错误，因此main 需要捕获错误。这可以委托给 process uncaughtRejection 事件处理程序，但它可能有益于它保持不应达到的额外错误处理级别。

我们看到的输出是控制台中记录了 Unhandled Promise 拒绝。

这不应该发生。拒绝需要由测试处理。上面解释了一个可能的故障点，foo 可以从apiCall 而不是CustomError 返回原始错误，以防它没有正确模拟，这将导致预期失败并导致catch() 中未处理的拒绝。另一个失败点是测试有 unchained promise，因为它没有被返回，测试总是通过。

使用 Promise 的异步测试应该总是返回一个 Promise。这可以通过使用async..await 来改进。 foo 是 async，它应该总是返回一个承诺：

it('foo should throw', async () => {
    foo.mockImplementantion(() => { return Promise.reject(new CustomError('error')) });
    await expect(bar()).rejects.toThrow(CustomError);
})

现在，即使 foo 模拟失败（foo 模拟不会影响 bar，如果它们在所示的相同模块中定义）并且 bar 拒绝了不是 CustomError 的东西，这将被断言。

Answer 2

没有。您不需要需要在每个 async/await 中使用 try/catch。您只需需要在顶层执行此操作。在这种情况下，您已经在执行 main 函数。

你应该的天气是一个见仁见智的问题。 go 语言设计者对此有足够的感觉，这已成为go 中的标准，始终在每个函数调用时处理错误。但这不是 javascript 或大多数其他语言的规范。

未处理的承诺拒绝

it() 函数抛出未处理的 Promise 拒绝，因为您没有告诉它等待 Promise 完成。

我假设您使用 mocha 之类的东西进行单元测试（其他框架的工作方式可能不同）。在 mocha 中有两种处理异步测试的方法：

1. 调用 done 回调 - it() 函数将始终使用 done 回调来调用。取决于你想使用它的天气，或者在你发布的代码中不使用它：

    describe('testing bar', () => {
        it('foo should throw', (done) => {
            foo.mockImplementantion(() => { throw new CustomError('error')});
            bar()
            .then((result) => {
                console.log(result);
                done(); // ------------- THIS IS YOUR ACTUAL BUG
             })
            .catch((err) => {
                exepect(err).toBeInstanceOf(CustomError);
                done(); // ------------- THIS IS YOUR ACTUAL BUG
            })
        })
    })
   

2. 返回一个承诺。如果您向it() 函数返回一个promise，mocha 将意识到您的代码是异步的并等待完成：

    describe('testing bar', () => {
        it('foo should throw', (done) => {
            foo.mockImplementantion(() => { throw new CustomError('error')});
   
            return bar() // <----------- THIS WOULD ALSO FIX IT
            .then((result) => {
                console.log(result);
             })
            .catch((err) => {
                exepect(err).toBeInstanceOf(CustomError);
            })
        })
    })
   

简而言之，您的代码没有任何问题。但是您的单元测试中有一个错误。

Answer 3

正如@Bergi 告诉我的，我会在这里发布一些解决方案

我将函数包装在 try catch 块中

1.

async function bar() {
    try{
       return foo()
    } catch (e) {
       throw e
    }
}

1. 重写测试

describe('testing bar', () => {
    it('foo should throw', (done) => {
        foo.mockImplementantion(() => { throw new CustomError('error')});
        bar()
        .then((result) => { throw result }) // this is because we are expecting an error, so if the promise resolves it's actually a bad sign.
        .catch((err) => { 
          exepect(err).toBeInstanceOf(CustomError)}) // this is what we are testing
          done();
    })
})

1. 在测试用例中使用return

describe('testing bar', () => {
    it('foo should throw', () => {
        foo.mockImplementantion(() => { throw new CustomError('error')});
        return bar()
        .then((result) => { throw result })
        .catch((err) => { exepect(err).toBeInstanceOf(CustomError)}) // this is what we are testing
    })
})