How to assert that "some" value is emitted by an RxJS Observable - jestjs

Question

When testing an observable that emits values, I want to assert that, eventually, a value will be emitted. For each value to test, I want to be able to use a matcher, similar to the .resolves matcher.
import { from } from 'rxjs';
test('observable eventually matches value', async () => {
const testObservable$ = from([{ a: 1 }, { a: 2 }, { a: 3 }]);
await expect(testObservable$).some.toMatch({ a: 2 });
});
Testing the first or last value would be simple enough using lastValueFrom and firstValueFrom. But in the case of firstValueFrom the test would become less resilient, as emitting any new "intermediate" values to the observable could break the test unduly.

Answer 1

First I'm going to assume that you wanted an observable that emits three separate values, rather than (as you've written) an observable that emits one array of three values.
Unless you want to write your own matcher (or find some existing RxJS Jest matcher library), the simplest way to do this is to write a helper to get a promise of whether or not a matching value was emitted from the observable, e.g.:
import { first, firstValueFrom, from, Observable } from 'rxjs';
test('observable eventually matches value', async () => {
const testObservable$ = from([{ a: 1 }, { a: 2 }, { a: 3 }]);
await expect(eventually(testObservable$, { a: 2 })).resolves.toBe(true);
});
function eventually<T>(stream$: Observable<T>, expected: T): Promise<boolean> {
return firstValueFrom(stream$.pipe(first((actual) => {
try {
expect(actual).toEqual(expected);
return true;
} catch {
return false;
}
}))).then(() => true).catch(() => false);
}
If a matching value is never emitted, this fails with either:
a comparison failure if the observable completes (including erroring) within the timeout:
Expected: true
Received: false
a timeout error otherwise:
thrown: "Exceeded timeout of 5000 ms for a test.
Use jest.setTimeout(newTimeout) to increase the timeout value, if this is a long-running test."

Answer 2

In case someone does want to add a dependency for this, I've created RxJeSt. Importing this package extends Jest's expect with a new .toEmit assertion for observables.
Create a minimal package in an empty directory with:
$ npm init --yes
$ npm install rxjs
$ npm install --save-dev jest rxjest
$ npm pkg set scripts.test=jest
then add the following to index.test.js:
require("rxjest");
const { from } = require("rxjs");
it("works like this", () => {
const testObservable$ = from([{ a: 1 }, { a: 2 }, { a: 3 }]);
return expect(testObservable$).toEmit({ a: 2 });
});
You should be able to run this with npm run test and see it fail:
$ npm t
> temp#0.1.0 test
> jest
FAIL ./index.test.js
✕ works like this (3 ms)
● works like this
expect(received).toEmit(expected) // deep equality
Expected value: "foo"
Emitted values: [{"a": 1}, {"a": 2}, {"a": 3}]
4 | it("works like this", () => {
5 | const testObservable$ = from([{ a: 1 }, { a: 2 }, { a: 3 }]);
> 6 | return expect(testObservable$).toEmit("foo");
| ^
7 | });
8 |
at Object.toEmit (index.test.js:6:34)
Test Suites: 1 failed, 1 total
Tests: 1 failed, 1 total
Snapshots: 0 total
Time: 0.306 s, estimated 1 s
Ran all test suites.
Now update the expected value to one that's actually emitted, e.g. .toEmit({ a: 2 });, and it should pass just fine.

Answer 3

I think you can simply subscribe to the observable and collect the values it emits into an array and run your assertions on that array e.g.
import test from 'tape';
import {delay, from} from 'rxjs';
test('emits 1, 2 & 3', t => {
const stream$ = from([1, 2, 3]);
const actual = [];
stream$.subscribe(x => actual.push(x));
t.same(actual, [1, 2, 3]);
t.end();
});
test('emits 1, 2 & 3 (async)', t => {
const stream$ = from([1, 2, 3]).pipe(delay(50));
const actual = [];
stream$.subscribe({
next(x) {
actual.push(x);
},
complete() {
t.same(actual, [1, 2, 3]);
t.end();
}
});
});