How to assert warnings?

[oscarmarcelo]

Asserting errors is pretty straightforward, as we all know, but... how can I assert warnings properly?

Here's two approaches I tried:

Overriding console.warn to throw an Error instead

This was pretty easy. Just monkeypatched console.warn to throw errors and then asserted them:

import test from 'ava';
import fn from './index.js';


console.warn = value => throw new Error(value);


test('test warning', t => {
  t.throws(
    () => {
      fn();
    },
    'warning message here',
  );
});

But I don't think this to be a good solution, because it will catch just the first "warning", and since a warning should not break, I can't assert for any subsequent warnings or even result/output of the code I'm testing.

Use emitWarning and collect their messages through the warning event

I believe using process.emitWarning is better than using console.warn in a Node package, as we get much more functionality, including events and command-line flags.

But, I'm currently stuck on this one, and honestly I don't know if it's still the best solution, or if we can do something better.

I'm trying to add/remove a listener to the warning event to collect all the warnings to a warning using beforeEach and afterEach hooks, and then compare the warnings in the test itself:

import test from 'ava';
import fn from './index.js';


warnings = {};


test.beforeEach(t => {
  const title = t.title.slice('beforeEach hook for '.length);

  t.context.warningCallback = ({message}) => {
    if (!Array.isArray(warnings[title])) {
      warnings[title] = [];
    }

    warnings[title].push(message);
  };

  process.prependListener('warning', t.context.warningCallback);
});


test.afterEach(t => {
  process.removeListener('warning', t.context.warningCallback);
});


test('test warning', t => {
  fn();

  t.deepEqual(warnings[t.title], [
    'warning message 1',
    'warning message 2',
  ]);
});

My issue here is that I can't get the warning messages in time. The test finishes before the event callback runs.

Also, I don't think I can monkeypatch emitWarning to silence the warnings to avoid noise in the middle of AVA's terminal output...

---

So, how can I make this work? Am I doing this entirely wrong?

[novemberborn]

I'd venture the event is emitted asynchronously, so your hooks are not capturing them.

Instead make your test wait for the next warning:

import { once } from 'node:events'
import process from 'node:process'
import test from 'ava'

test('test warning', async t => {
  const next = once(process, 'warning')
  fn()
  const warning = await next
  t.deepEqual(warning, …)
})

Of course this assumes nothing else is emitting warnings.

[oscarmarcelo]

Thanks for the answer!

Although this solves the async issue, once will catch only the first warning, having the same shortcoming of my first approach...

I thought about using on instead, but since there isn't an off in node:events and on returns an AsyncIterator, no promise is ever returned due to the endless for await loop and AVA complains about it. I even tried the AbortController approach as suggested in Node's documentation, to no avail...

One other (maybe) solution I'm considering is to make fn() a method of an EventEmitter class that returns a promise, and I could listen to that class' warning events until the promise gets resolved.
Do you think it could be a good idea, or do you have a better one?

[novemberborn]

You should be able to break out of the for await after the last expected warning. You can also iterate manually const iterator = on(process, 'warning')[Symbol.asyncIterator]() and iterator.next(), that would let you set up a Promise.race() with another promise that resolves after a short amount of time (import {setTimeout as delay} from 'node:timers/promise';delay(500). You may have to iterator.return() when you want to break if the timeout is hit though.