mirror of
https://github.com/joelwmale/webhook-action.git
synced 2024-11-26 09:25:24 +01:00
90 lines
2.1 KiB
Markdown
90 lines
2.1 KiB
Markdown
# Avoid using a callback in asynchronous tests and hooks (`no-done-callback`)
|
|
|
|
When calling asynchronous code in hooks and tests, `jest` needs to know when the
|
|
asynchronous work is complete to progress the current run.
|
|
|
|
Originally the most common pattern to archive this was to use callbacks:
|
|
|
|
```js
|
|
test('the data is peanut butter', done => {
|
|
function callback(data) {
|
|
try {
|
|
expect(data).toBe('peanut butter');
|
|
done();
|
|
} catch (error) {
|
|
done(error);
|
|
}
|
|
}
|
|
|
|
fetchData(callback);
|
|
});
|
|
```
|
|
|
|
This can be very error prone however, as it requires careful understanding of
|
|
how assertions work in tests or otherwise tests won't behave as expected.
|
|
|
|
For example, if the `try/catch` was left out of the above code, the test would
|
|
timeout rather than fail. Even with the `try/catch`, forgetting to pass the
|
|
caught error to `done` will result in `jest` believing the test has passed.
|
|
|
|
A more straightforward way to handle asynchronous code is to use Promises:
|
|
|
|
```js
|
|
test('the data is peanut butter', () => {
|
|
return fetchData().then(data => {
|
|
expect(data).toBe('peanut butter');
|
|
});
|
|
});
|
|
```
|
|
|
|
When a test or hook returns a promise, `jest` waits for that promise to resolve,
|
|
as well as automatically failing should the promise reject.
|
|
|
|
If your environment supports `async/await`, this becomes even simpler:
|
|
|
|
```js
|
|
test('the data is peanut butter', async () => {
|
|
const data = await fetchData();
|
|
expect(data).toBe('peanut butter');
|
|
});
|
|
```
|
|
|
|
## Rule details
|
|
|
|
This rule checks the function parameter of hooks & tests for use of the `done`
|
|
argument, suggesting you return a promise instead.
|
|
|
|
The following patterns are considered warnings:
|
|
|
|
```js
|
|
beforeEach(done => {
|
|
// ...
|
|
});
|
|
|
|
test('myFunction()', done => {
|
|
// ...
|
|
});
|
|
|
|
test('myFunction()', function (done) {
|
|
// ...
|
|
});
|
|
```
|
|
|
|
The following patterns are not considered warnings:
|
|
|
|
```js
|
|
beforeEach(async () => {
|
|
await setupUsTheBomb();
|
|
});
|
|
|
|
test('myFunction()', () => {
|
|
expect(myFunction()).toBeTruthy();
|
|
});
|
|
|
|
test('myFunction()', () => {
|
|
return new Promise(done => {
|
|
expect(myFunction()).toBeTruthy();
|
|
done();
|
|
});
|
|
});
|
|
```
|