Dealing with Promises

First, thanks for the lib! I’ve successfully written several tests, and it’s very effective.

I hit a wall recently though when attempting to test an observable that mergeMaps a Promise (in my case, one that waits on a network request, which I’ve stubbed in the test with nock).

Simplified example:

  it('promises', marbles(m => {
    const obs1 = Observable.from(['a','b','c']).mergeMap(x => Observable.of(x))
    m.equal(obs1, '(abc|)') // Works

    const obs2 = Observable.from(['a','b','c']).mergeMap(x => Promise.resolve(x))
    m.equal(obs2, '(abc|)') // Fails
  }))

The second assertion fails with:

     Error:
Expected

to deep equal
	{"frame":0,"notification":{"kind":"N","value":"a","hasValue":true}}
	{"frame":0,"notification":{"kind":"N","value":"b","hasValue":true}}
	{"frame":0,"notification":{"kind":"N","value":"c","hasValue":true}}
	{"frame":0,"notification":{"kind":"C","hasValue":false}}

I assume this is because Promises (the native implementation, anyway) always resolves on the next tick, while marble testing is intended to test the observable within one tick.

Is my only option to do something hacky like mock the function that returns a promise to return a Observable.of() stubbed value instead?

[cartant]

Yep. You are correct.

The problem is that promises always resolve asynchronously, so your mock is still asynchronous and not compatible with the TestScheduler - which runs the subscriptions in a synchronous manner when its flush method is called (usually at the end of each test). That’s why the Expected output is empty - the test has finished before the promise resolved.

You are also correct in that the solution would involve mocking the promise with something the TestScheduler understands and can treat in a synchronous manner (either a synchronous observable - like Observable.of - or an asynchronous observable that takes the TestScheduler instance as a parameter).

Being able to use marble tests with observables that cannot be made to use virtual time is something that I have on my list of problems to solve, but I’ve not yet devoted any time to it. I have a large number of mocked Firebase tests - written about 12 months ago - that would have been much easier to write using marble tests. Finding a solution is something that will likely wait until I again need to write a substantial number of tests for non-virtual-time observables.

[nmccready]

Ok, I think I was looking more for direction in how asynchronous stuff is handled within the marble callback. In jest it still supports returning promises. So this is exactly what I needed.

const bindMouseEvents = jest.fn(); // injected into module
describe('some epics', () => {
  it(
    viewerMouseEvents.name,
    marbles((m) => {
      const action$ = m.hot('-a-|', {
        a: { type: 'SOME_EVENT', payload: {} }
      });

      // ignore elements strips all elements but errors and completes
      const expected = m.cold('---|');

      const state$ = {};

      const out = viewerMouseEvents(action$, state$);
      m.expect(out).toBeObservable(expected);
      return out
        .toPromise() // don't miss and make sure stuff internally is called
        .then(() => expect(bindMouseEvents).toHaveBeenCalled());
    })
  );
});

Hope this helps someone else.