feat: obsolete snapshots get flagged and -u cleans them up

src/reporter/base.ts

@@ -21,6 +21,7 @@ type TestSummary = {
     failed: number;
     written: number;
     updated: number;
+    obsolete: number;
   };
 };
 
@@ -71,8 +72,8 @@ export class BaseReporter {
   endTest(test: TestCase, result: TestResult): void {
     if (!this.isTTY) this.currentTest += 1;
   }
-  end(rootSuite: Suite): number {
-    const summary = this._generateSummary(rootSuite);
+  end(rootSuite: Suite, obsoleteSnapshots: number): number {
+    const summary = this._generateSummary(rootSuite, obsoleteSnapshots);
 
     this._printFailures(summary);
     this._printSummary(summary);
@@ -81,17 +82,26 @@ export class BaseReporter {
     ).length;
   }
 
-  private _generateSummary(rootSuite: Suite): TestSummary {
+  private _generateSummary(
+    rootSuite: Suite,
+    obsoleteSnapshots: number
+  ): TestSummary {
     let didNotRun = 0;
     let skipped = 0;
     let expected = 0;
     const unexpected: TestCase[] = [];
     const flaky: TestCase[] = [];
-    const snapshots = { written: 0, updated: 0, failed: 0, passed: 0 };
+    const snapshots = {
+      written: 0,
+      updated: 0,
+      failed: 0,
+      passed: 0,
+      obsolete: obsoleteSnapshots,
+    };
 
     rootSuite.allTests().forEach((test) => {
       test.snapshots().forEach((snapshot) => {
-        switch (snapshot) {
+        switch (snapshot.result) {
           case "passed":
             snapshots.passed++;
             break;
@@ -185,21 +195,25 @@ export class BaseReporter {
     if (snapshots.written > 0) {
       snapshotTokens.push(chalk.green(`${snapshots.written} written`));
     }
+    if (snapshots.obsolete > 0) {
+      snapshotTokens.push(chalk.yellow(`${snapshots.obsolete} obsolete`));
+    }
 
     const snapshotTotal =
       snapshots.passed +
       snapshots.failed +
       snapshots.written +
-      snapshots.updated;
-    const snapshotErrorPostfix =
-      snapshots.failed > 0
+      snapshots.updated +
+      snapshots.obsolete;
+    const snapshotPostfix =
+      snapshots.failed > 0 || snapshots.obsolete > 0
         ? chalk.dim(
             "(Inspect your code changes or use the `-u` flag to update them.)"
           )
         : "";
     if (snapshotTotal !== 0) {
       process.stdout.write(
-        `  snapshots: ${snapshotTokens.join(", ")}, ${snapshotTotal} total ${snapshotErrorPostfix}\n\n`
+        `  snapshots: ${snapshotTokens.join(", ")}, ${snapshotTotal} total ${snapshotPostfix}\n\n`
       );
     } else {
       process.stdout.write("\n");

src/reporter/list.ts

@@ -48,8 +48,8 @@ export class ListReporter extends BaseReporter {
     this._updateOrAppendLine(row, line, prefix);
   }
 
-  override end(rootSuite: Suite): number {
-    return super.end(rootSuite);
+  override end(rootSuite: Suite, obsoleteSnapshots: number): number {
+    return super.end(rootSuite, obsoleteSnapshots);
   }
 
   private _resultIcon(status: TestStatus): string {

src/runner/runner.ts

@@ -17,6 +17,7 @@ import { BaseReporter } from "../reporter/base.js";
 import { TestCase } from "../test/testcase.js";
 import { cacheFolderName, executableName } from "../utils/constants.js";
 import { supportsColor } from "chalk";
+import { cleanSnapshot } from "../test/matchers/toMatchSnapshot.js";
 
 /* eslint-disable no-var */
 
@@ -131,6 +132,28 @@ const checkShellSupport = (shells: Shell[]) => {
   }
 };
 
+const cleanSnapshots = async (
+  tests: TestCase[],
+  { updateSnapshot }: ExecutionOptions
+) => {
+  const snapshotFiles = tests.reduce((snapshots, test) => {
+    const source = test.filePath() ?? "";
+    const snapshotNames = test.snapshots().map((snapshot) => snapshot.name);
+    snapshots.set(source, [...(snapshots.get(source) ?? []), ...snapshotNames]);
+    return snapshots;
+  }, new Map<string, string[]>());
+
+  let unusedSnapshots = 0;
+  for (const snapshotFile of snapshotFiles.keys()) {
+    unusedSnapshots += await cleanSnapshot(
+      snapshotFile,
+      new Set(snapshotFiles.get(snapshotFile)),
+      updateSnapshot
+    );
+  }
+  return unusedSnapshots;
+};
+
 export const run = async (options: ExecutionOptions) => {
   checkNodeVersion();
 
@@ -216,6 +239,8 @@ export const run = async (options: ExecutionOptions) => {
   } catch {
     /* empty */
   }
-  const failures = reporter.end(rootSuite);
+  const obsoleteSnapshots = await cleanSnapshots(allTests, options);
+  const failures = reporter.end(rootSuite, obsoleteSnapshots);
+
   process.exit(failures);
 };

src/runner/worker.ts

@@ -7,9 +7,8 @@ import workerpool from "workerpool";
 import { Suite } from "../test/suite.js";
 import { spawn } from "../terminal/term.js";
 import { defaultShell } from "../terminal/shell.js";
-import { TestCase, TestStatus } from "../test/testcase.js";
+import { Snapshot, TestCase, TestStatus } from "../test/testcase.js";
 import { expect } from "../test/test.js";
-import { SnapshotStatus } from "../test/matchers/toMatchSnapshot.js";
 import { BaseReporter } from "../reporter/base.js";
 import { poll } from "../utils/poll.js";
 import { flushSnapshotExecutionCache } from "../test/matchers/toMatchSnapshot.js";
@@ -20,7 +19,7 @@ type WorkerResult = {
   stderr?: string;
   status: TestStatus;
   duration: number;
-  snapshots: SnapshotStatus[];
+  snapshots: Snapshot[];
 };
 
 type WorkerExecutionOptions = {
@@ -103,7 +102,7 @@ export async function runTestWorker(
   pool: workerpool.Pool,
   reporter: BaseReporter
 ): Promise<WorkerResult> {
-  const snapshots: SnapshotStatus[] = [];
+  const snapshots: Snapshot[] = [];
   if (test.expectedStatus === "skipped") {
     reporter.startTest(test, {
       status: "pending",
@@ -152,7 +151,10 @@ export async function runTestWorker(
               reportStarted = true;
               startTime = payload.startTime;
             } else if (payload.snapshotResult) {
-              snapshots.push(payload.snapshotResult);
+              snapshots.push({
+                name: payload.snapshotName,
+                result: payload.snapshotResult,
+              });
             }
           },
         }

src/test/matchers/toMatchSnapshot.ts

@@ -72,6 +72,38 @@ const updateSnapshot = async (
   await fh.close();
 };
 
+export const cleanSnapshot = async (
+  testPath: string,
+  retainedSnapshots: Set<string>,
+  updateSnapshot: boolean
+): Promise<number> => {
+  const snapPath = snapshotPath(testPath);
+  if (!fs.existsSync(snapPath)) return retainedSnapshots.size;
+  const snapshots = require(snapPath);
+  const unusedSnapshots = Object.keys(snapshots).filter(
+    (snapshot) => !retainedSnapshots.has(snapshot)
+  );
+
+  if (!updateSnapshot) return unusedSnapshots.length;
+  unusedSnapshots.forEach((unusedSnapshot) => {
+    delete snapshots[unusedSnapshot];
+  });
+
+  await fsAsync.writeFile(
+    snapPath,
+    "// TUI Test Snapshot v1\n\n" +
+      Object.keys(snapshots)
+        .sort()
+        .map(
+          (snapshotName) =>
+            `exports[\`${snapshotName}\`] = String.raw\`\n${snapshots[snapshotName].trim()}\n\`;\n\n`
+        )
+        .join("")
+  );
+
+  return unusedSnapshots.length;
+};
+
 const generateSnapshot = (terminal: Terminal, includeColors: boolean) => {
   const { view, shifts } = terminal.serialize();
   if (shifts.size === 0 || !includeColors) {
@@ -108,14 +140,17 @@ export async function toMatchSnapshot(
   const snapshotEmpty = existingSnapshot == null;
 
   if (!workpool.isMainThread) {
-    const snapshotResult = snapshotEmpty
+    const snapshotResult: SnapshotStatus = snapshotEmpty
       ? "written"
       : snapshotShouldUpdate
         ? "updated"
         : snapshotsDifferent
           ? "failed"
           : "passed";
-    workpool.workerEmit({ snapshotResult, testName });
+    workpool.workerEmit({
+      snapshotResult,
+      snapshotName: snapshotPostfixTestName,
+    });
   }
 
   if (snapshotEmpty || snapshotShouldUpdate) {

src/test/testcase.ts

@@ -21,11 +21,16 @@ export type TestStatus =
   | "skipped"
   | "flaky";
 
+export type Snapshot = {
+  name: string;
+  result: SnapshotStatus;
+};
+
 export type TestResult = {
   status: TestStatus;
   error?: string;
   duration: number;
-  snapshots: SnapshotStatus[];
+  snapshots: Snapshot[];
   stdout?: string;
   stderr?: string;
 };
@@ -64,7 +69,7 @@ export class TestCase {
     return "unexpected";
   }
 
-  snapshots(): SnapshotStatus[] {
+  snapshots(): Snapshot[] {
     return this.results.at(-1)?.snapshots ?? [];
   }