How to run OS-agnostic Jest test files that check paths? - node.js

Question

Let's say I have the following:
expect(func).toHaveBeenCalledWith('/path/to/file');
This would work fine on NIX operating systems. However, this test would fail on Windows platform because I should instead have
expect(func).toHaveBeenCalledWith('\path\to\file');
What's the best way to write tests so they are OS agnostic? I was looking at this article but that is basically saying write different tests for different OSes.

Answer 1

In general, you can extend expect to add the matching behaviour you want, there are lots of examples in jest-extended. For this case, perhaps using the tools available in path to test against the appropriate path for whatever OS the tests are running on:
import { matcherHint, printExpected, printReceived } from "jest-matcher-utils";
import * as path from "path";
expect.extend({
toMatchPath: (actual, expected) => {
const normalised = path.join(...expected.split("/"));
return actual === normalised
? { pass: true, message: passMessage(actual, normalised) }
: { pass: false, message: failMessage(actual, normalised) };
},
});
const passMessage = (actual, expected) => () => `${matcherHint(".not.toMatchPath")}
Expected value not to match:
${printExpected(expected)}
Received:
${printReceived(actual)}`;
const failMessage = (actual, expected) => () => `${matcherHint(".toMatchPath")}
Expected value to match:
${printExpected(expected)}
Received:
${printReceived(actual)}`;
In your tests you then always write POSIX-style paths /path/to/thing, and path takes care of providing the appropriate path separator for the current OS. In use:
describe("path matching", () => {
const actual = path.join("path", "to", "thing");
it("normalises paths for matching", () => {
expect(actual).toMatchPath("path/to/thing");
});
it("can be negated", () => {
expect(actual).not.toMatchPath("path/to/other/thing");
});
it("can be used asymmetrically", () => {
const fn = jest.fn();
fn(actual);
expect(fn).toHaveBeenCalledWith(expect.toMatchPath("path/to/thing"));
});
it("fails usefully", () => {
const fn = jest.fn();
fn(actual);
expect(fn).toHaveBeenCalledWith(expect.not.toMatchPath("path/to/thing"));
});
});
Output:
path matching
✓ normalises paths for matching (3 ms)
✓ can be negated
✓ can be used asymmetrically (2 ms)
✕ fails usefully (3 ms)
● path matching › fails usefully
expect(jest.fn()).toHaveBeenCalledWith(...expected)
Expected: not.toMatchPath<path/to/thing>
Received: "path/to/thing"
Number of calls: 1
44 | const fn = jest.fn();
45 | fn(actual);
> 46 | expect(fn).toHaveBeenCalledWith(expect.not.toMatchPath("path/to/thing"));
| ^
47 | });
48 | });
at Object.toHaveBeenCalledWith (server/demo.test.js:46:14)
Test Suites: 1 failed, 1 total
Tests: 1 failed, 3 passed, 4 total
Snapshots: 0 total