fp-ts and jest: ergonomic tests for Option and Either?

Question

I'm using fp-ts, and I write unit tests with Jest. In many cases, I'm testing nullable results, often represented with Option or Either (typically, array finds). What is the most ergonomic way to make the test fail if the result is none (taking Option as an example), and keep on going knowing that this result is some?

Here's an example of how I can solve the problem at the moment:

function someFunc(input: string): Option.Option<string> {
  return Option.some(input);
}

describe(`Some suite`, () => {
  it(`should do something with a "some" result`, () => {
    const result = someFunc('abcd');

    // This is a fail case, here I'm expecting result to be Some
    if(Option.isNone(result)) {
      expect(Option.isSome(result)).toEqual(true);
      return;
    }

    expect(result.value).toEqual('abcd');
  });
});

But having to write an if with an early return is not very ergonomic.

I could alternatively write an as assertion:

  // ...
  it(`should do something with a "some" result`, () => {
    const result = someFunc('abcd') as Option.Some<string>;

    expect(result.value).toEqual('abcd');
  });
  // ...

But the downside there is that I have to rewrite the some's type. In many cases, having to write it is heavy, requiring to write and export interface for the sole purpose of testing (which is not ergonomic either).

Is there any way to simplify this kind of test?

Edit: Here is a test case that's closer to real conditions:

interface SomeComplexType {
  id: string,
  inputAsArray: string[],
  input: string;
}

function someFunc(input: string): Option.Option<SomeComplexType> {
  return Option.some({
    id: '5',
    inputAsArray: input.split(''),
    input,
  });
}

describe(`Some suite`, () => {
  it(`should do something with a "some" result`, () => {
    const result = someFunc('abcd');

    // This is the un-ergonomic step
    if(Option.isNone(result)) {
      expect(Option.isSome(result)).toEqual(true);
      return;
    }

    // Ideally, I would only need this:
    expect(Option.isSome(result)).toEqual(true);
    // Since nothing will be ran after it if the result is not "some"
    // But I can imagine it's unlikely that TS could figure that out from Jest expects

    // Since I now have the value's actual type, I can do a lot with it
    // I don't have to check it for nullability, and I don't have to write its type
    const myValue = result.value;

    expect(myValue.inputAsArray).toEqual(expect.arrayContaining(['a', 'b', 'c', 'd']));

    const someOtherThing = getTheOtherThing(myValue.id);

    expect(someOtherThing).toMatchObject({
      another: 'thing',
    });
  });
});

Answer 1

How about toNullable or toUndefined? Given Option<string>, toNullable returns string | null.

import { toNullable, toUndefined } from "fp-ts/lib/Option";

it(`should do something with a "some" result`, () => {
  expect(toNullable(someFunc("abcd"))).toEqual("abcd");
});

---

The problem with expect(Option.isSome(result)).toEqual(true) is, type guard isSome cannot be used to narrow result in the outer code path of expect (see here how control flow analysis works).

You can use assertion functions which are a bit leaner and combine them with fp-ts type guards, e.g.:

import { isSome, Option } from "fp-ts/lib/Option"

function assert<T>(guard: (o: any) => o is T, o: any): asserts o is T {
  if (!guard(o)) throw new Error() // or add param for custom error
}

it(`a test`, () => {
  const result: Option<string> = {...}
  assert(isSome, result)
  // result is narrowed to type "Some" here
  expect(result.value).toEqual('abcd');
});

I don't know if there is a good way of augmenting Jest expect function type itself with a type guard signature, but I doubt it simplifies your case instead of a simple assertion or above solutions.

Answer 2

You can write an unsafe conversion fromSome like so:

function fromSome<T>(input: Option.Option<T>): T {
  if (Option.isNone(input)) {
    throw new Error();
  }
  return input.value;
}

And then use it in the tests

  it(`should do something with a "some" result`, () => {
    const result = someFunc('abcd');
    const myValue = fromSome(result);
    // do something with myValue
  });

Answer 3

This question is a little old at this point and has an accepted answer, but there are couple really nice libraries that make testing fp-ts Either and Option really pleasant. They both work really well and I can't really decide which I like better.

• https://github.com/relmify/jest-fp-ts
• https://github.com/svdo/fp-ts-jest-matchers

They allow you to write things like this:

test('some test', () => {
  expect(E.left({ code: 'invalid' })).toSubsetEqualLeft({ code: 'invalid' })
})