jest/no-conditional-in-test and type narrowing

[jamesarosen]

Given a function that uses the Result Pattern:

type FooResult =
  | { ok: true; value: number }
  | { ok: false; error: Error }

function foo(n: number): FooResult {
  return (Number.isFinite(n)) ? { ok: true, value: 2 * n + 1 } : { ok: false, error: new Error('n is infinite') }
} 

I want to write a test:

describe('foo(3)', () => {
  const result = foo(3)
  expect(result.ok).toBe(true)
  expect(result.value).toBe(7) // TS fails
})

describe('foo(∞)', () => {
  const result = foo(Infinity)
  expect(result.ok).toBe(false)
  expect(result.error.message).toMatch(/infinite/) // TS fails
})

TypeScript fails because neither value nor error is defined on FooResult itself. It works if we narrow the type:

describe('foo(3)', () => {
  const result = foo(3)
  expect(result.ok).toBe(true)
  if (!result.ok) throw new Error('test error')
  expect(result.value).toBe(7)
})

describe('foo(∞)', () => {
  const result = foo(Infinity)
  expect(result.ok).toBe(false)
  if (result.ok) throw new Error('test error')
  expect(result.error.message).toMatch(/infinite/)
})

But that (a) requires doubling each such assertion and (b) violates jest/no-conditional-in-test, which is overall a sensible rule.

We can fix it by making teaching TypeScript about the assertion:

assertIsFalse(b: boolean): asserts b is true {
  expect(b).toBe(false)
}

assertIsTrue(b: boolean): asserts b is true {
  expect(b).toBe(true)
}

describe('foo(3)', () => {
  const result = foo(3)
  assertIsTrue(result.ok)
  expect(result.value).toBe(7)
})

describe('foo(∞)', () => {
  const result = foo(Infinity)
  assertIsFalse(result.ok) // assertIsTrue(!result.ok) doesn't narrow
  expect(result.error.message).toMatch(/infinite/)
})

That seems... awkward.

Does anyone have any ideas?

[hi-ogawa]

This is working https://stackblitz.com/edit/vitest-dev-vitest-bjrcixdf?file=test%2Frepro.test.ts

import { expect, test } from 'vitest';

test('foo(3)', () => {
  const result = foo(3);
  expect.assert(result.ok);
  expect(result.value).toBe(7);
});

test('foo(∞)', () => {
  const result = foo(Infinity);
  expect.assert(!result.ok);
  expect(result.error.message).toMatch(/infinite/);
});

type FooResult = { ok: true; value: number } | { ok: false; error: Error };

function foo(n: number): FooResult {
  return Number.isFinite(n)
    ? { ok: true, value: 2 * n + 1 }
    : { ok: false, error: new Error('n is infinite') };
}

[jamesarosen]

expect.assert is exactly what I was looking for! Thank you :)