refactor: add setup instead

Author: AriPerkkio

src/fixtures/file-system.ts

@@ -68,11 +68,13 @@ export class FileSystem {
     return this._instance.fs.rm(path);
   }
 
-  async export(path = "./", options = { excludes: [], includes: [] }) {
-    return await this._instance.export(path, { ...options, format: "binary" });
+  /** @internal */
+  async export() {
+    return await this._instance.export("./", { format: "binary" });
   }
 
+  /** @internal */
   async restore(snapshot: Uint8Array) {
-    return await this._instance.mount(snapshot);
+    return await this._instance.mount(new Uint8Array(snapshot));
   }
 }

src/fixtures/index.ts

@@ -6,6 +6,10 @@ import { WebContainer } from "./webcontainer";
 export interface TestContext {
   preview: Preview;
   webcontainer: WebContainer;
+  setup: (callback: () => Promise<void>, timers?: boolean) => Promise<void>;
+
+  /** @internal */
+  _internalState: { current: Uint8Array | undefined };
 }
 
 /**
@@ -30,6 +34,9 @@ export interface TestContext {
  * ```
  */
 export const test = base.extend<TestContext>({
+  /** @internal */
+  _internalState: { current: undefined },
+
   preview: async ({ webcontainer }, use) => {
     await webcontainer.wait();
 
@@ -60,4 +67,29 @@ export const test = base.extend<TestContext>({
 
     await webcontainer.teardown();
   },
+
+  setup: async ({ _internalState, webcontainer }, use) => {
+    await use(async (callback, timers = false) => {
+      const start = timers ? performance.now() : 0;
+
+      if (_internalState.current) {
+        await webcontainer.restore(_internalState.current);
+
+        if (timers) {
+          console.log(`[restore] ${(performance.now() - start).toFixed(2)}ms`);
+        }
+
+        return;
+      }
+
+      await callback();
+
+      // save current state in fixture
+      _internalState.current = await webcontainer.export();
+
+      if (timers) {
+        console.log(`[setup] ${(performance.now() - start).toFixed(2)}ms`);
+      }
+    });
+  },
 });

test/setup.test.ts

@@ -0,0 +1,25 @@
+import { beforeEach, expect } from "vitest";
+import { test, type TestContext } from "../src";
+
+const counts = { setup: 0, beforeEach: 0 };
+
+beforeEach<TestContext>(async ({ setup, webcontainer }) => {
+  await setup(async () => {
+    await webcontainer.writeFile("./example", "Hello world");
+    counts.setup++;
+
+    expect(counts.setup).toBe(1);
+  });
+
+  counts.beforeEach++;
+});
+
+test.for([1, 2, 3])("state is restored %d", async (count, { webcontainer }) => {
+  await expect(webcontainer.readFile("example")).resolves.toBe("Hello world");
+
+  // setup should always be called just once as it's cached
+  expect(counts.setup).toBe(1);
+
+  // hook itself is called each time
+  expect(counts.beforeEach).toBe(count);
+});