[WIP] bun test to support snapshots

[ethanburrell]

Adds support for snapshots by bun-test as proposed in #1642 and #1825.

This PR implements the following function:

expect(...).toMatchSnapshot(hint?: string): void

This is very similar to Jest's toMatchSnapshot, a tool to test if a visual component or object has changed. If a file needs to have a new snapshot generated then pass the --updateSnapshot argument to bun wiptest and a new snapshot file will be generated.

There are two key differences between bun's implementation of toMatchSnapshot and Jest's implementation:

1. The formatting of snapshot files is provided by bun's formatter and not the one that Jest uses which leads to objects to be stringified in a different format than in Jest. If migrating from a Jest codebase you will need to --updateSnapshot for your tests to pass.

2. This does not currently support the Property Matchers argument. This will be updated after some features are added to wiptest.

Open questions for reviewers:

1. First time writing a major feature in Zig! Any style or conventions tips would be appreciated.
2. Would like some guidance on how to handle mis-formatted snapshot files. See comment below

[ethanburrell]

I need to unblock #1533 and #1591 to move forward with the next parts of this ticket.

[ethanburrell]

propertyMatchers need something like the Expect Any Constructor to work correctly.

[ethanburrell]

The function parseSnapshot uses the same logic as jest to parse the snapshot file.

Currently if the snapshot file is mis-formatted this will cause a segfault in bun. How can I add error handling so the test can fail normally if the snapshot is mis-formatted?

[ethanburrell]

Overview of how this function works:

If a snapshot file is formatted like:

exports[`test that the string is five`] = `5`;

The jest library / this snapshot logic will run the equivalent javascript code

      snapshotContents = fs.readFileSync(snapshotPath, 'utf8');
      // eslint-disable-next-line no-new-func
      const populate = new Function('exports', snapshotContents);
      populate(data);

Which will transform the data into an object that looks like the following:

exports = { `test that the string is five`: `5` }

However when the input snapshot file is incorrectly formatted it can cause the bun to segfault. For example if the snapshot file saved looks like:

`test that the string is five` = `5`;

Then the program will segfault at snapshot.zig:149. How can catch an exception from the zig call to JSObjectCallAsFunction? This is equivalent to the const populate = new Function('exports', snapshotContents); line from the Jest program.

[Jarred-Sumner]

I don't think this needs to be JavaScript source code

We can print it to look like JavaScript code to match Jest behavior, but assuming snapshots are always plain text - it could be a file parsed with Bun's JS parser and then printed with Bun's JS printer afterwards.

There are several garbage collector things in here that will cause segfaults in the current implementation

[ethanburrell]

I don't know where to add docs on how to use this.

[Jarred-Sumner]

We unfortunately can't use exists from FilenameStore or DirnameStore here because that function checks if the path string was allocated into it, not anything to do with the filesystem. Those stores are big chunks of preallocated memory for storing file path strings

[Jarred-Sumner]

This string is potentially a UTF-8 string that needs to be re-encoded (call .withEncoding())

[Jarred-Sumner]

I'm not sure that we can use the console.log formatter in here. Is that what Jest does? Bun's console.log formatter doesn't deeply visit every nested object and it doesn't visit every JSX child element

[Jarred-Sumner]

Thank you very much for this

There are two main issues with this approach:

1. Using JavaScript wrapper functions for exports means that everything in/out of the snapshots need to be reachable by the garbage collector - which means its very easy to cause segfaults. Instead, the keys and values should be UTF-8 string. If we need to make the snapshot format match Jest (which means parsing JS), since the values are exports[identifier] = 'string literal' this can be done by bun's JS parser without invoking JS at all

2. To capture the snapshot, we need to do something that's not quite using the rest of the console.log code. console.log doesn't deeply snapshot objects. We probably should use something like JSON.stringify except with a way to handle Symbol, JSX, ignore functions and other things which are not clonable. For this, it would be good to look at Jest's implementation and then possibly implement it in C++ (potentially similar to Bun__deepEquals except instead of comparing equality, it would write the snapshot string?)

[Electroid]

Thanks for working on this. We recently added support for snapshots.