How to stub Fluture?

Question

Background

I am trying to convert a code snippet from good old Promises into something using Flutures and Sanctuary:

https://codesandbox.io/embed/q3z3p17rpj?codemirror=1

Problem

Now, usually, using Promises, I can uses a library like sinonjs to stub the promises, i.e. to fake their results, force to resolve, to reject, ect.

This is fundamental, as it helps one test several branch directions and make sure everything works as is supposed to.

With Flutures however, it is different. One cannot simply stub a Fluture and I didn't find any sinon-esque libraries that could help either.

Questions

1. How do you stub Flutures ?
2. Is there any specific recommendation to doing TDD with Flutures/Sanctuary?

Answer 1

I'm not sure, but those Flutures (this name! ... nevermind, API looks cool) are plain objects, just like promises. They only have more elaborate API and different behavior.

Moreover, you can easily create "mock" flutures with Future.of, Future.reject instead of doing some real API calls.

Yes, sinon contains sugar helpers like resolves, rejects but they are just wrappers that can be implemented with callsFake.

So, you can easily create stub that creates fluture like this.

someApi.someFun = sinon.stub().callsFake((arg) => {
    assert.equals(arg, 'spam');
    return Future.of('bar');
});

Then you can test it like any other API. The only problem is "asynchronicity", but that can be solved like proposed below.

// with async/await
it('spams with async', async () => {
    const result = await someApi.someFun('spam).promise();
    assert.equals(result, 'bar');
});

// or leveraging mocha's ability to wait for returned thenables
it('spams', async () => {
    return someApi.someFun('spam)
        .fork(
             (result) => { assert.equals(result, 'bar');},
             (error) => { /* ???? */ }
        )
        .promise();
});

Answer 2

As Zbigniew suggested, Future.of and Future.reject are great candidates for mocking using plain old javascript or whatever tools or framework you like.

To answer part 2 of your question, any specific recommendations how to do TDD with Fluture. There is of course not the one true way it should be done. However I do recommend you invest a little time in readability and ease of writing tests if you plan on using Futures all across your application.

This applies to anything you frequently include in tests though, not just Futures. The idea is that when you are skimming over test cases, you will see developer intention, rather than boilerplate to get your tests to do what you need them to.

In my case I use mocha & chai in the BDD style (given when then). And for readability I created these helper functions.

const {expect} = require('chai');

exports.expectRejection = (f, onReject) =>
    f.fork(
        onReject,
        value => expect.fail(
            `Expected Future to reject, but was ` +
            `resolved with value: ${value}`
        )
    );

exports.expectResolve = (f, onResolve) =>
    f.fork(
        error => expect.fail(
            `Expected Future to resolve, but was ` +
            `rejected with value: ${error}`
        ),
        onResolve
    );

As you can see, nothing magical going on, I simply fail the unexpected result and let you handle the expected path, to do more assertions with that.

Now some tests would look like this:

const Future = require('fluture');
const {expect} = require('chai');
const {expectRejection, expectResolve} = require('../util/futures');

describe('Resolving function', () => {
    it('should resolve with the given value', done => {
        // Given
        const value = 42;
        // When
        const f = Future.of(value);
        // Then
        expectResolve(f, out => {
            expect(out).to.equal(value);
            done();
        });
    });
});

describe('Rejecting function', () => {
    it('should reject with the given value', done => {
        // Given
        const value = 666;
        // When
        const f = Future.of(value);
        // Then
        expectRejection(f, out => {
            expect(out).to.equal(value);
            done();
        });
    });
});

And running should give one pass and one failure.

  ✓ Resolving function should resolve with the given value: 1ms
  1) Rejecting function should reject with the given value

  1 passing (6ms)
  1 failing

  1) Rejecting function
       should reject with the given value:
     AssertionError: Expected Future to reject, but was resolved with value: 666

Do keep in mind that this should be treated as asynchronous code. Which is why I always accept the done function as an argument in it() and call it at the end of my expected results. Alternatively you could change the helper functions to return a promise and let mocha handle that.