jest-image-snapshot 4.0.0 → 4.2.0

package/.github/workflows/stale.yml

@@ -10,13 +10,14 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/stale@v1
+    - uses: actions/stale@v3
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-issue-message: 'This issue is stale because it has been open 30 days with no activity.'
         stale-pr-message: 'This pull request is stale because it has been open 30 days with no activity.'
         stale-issue-label: 'stale-issue'
-        exempt-issue-label: 'stale-issue'
-        exempt-pr-label: 'stale-pr'
+        exempt-issue-labels: 'enhancement,documentation,good-first-issue,question,bug'
         stale-pr-label: 'stale-pr'
+        exempt-pr-labels: 'work-in-progress'
         days-before-stale: 30
+        days-before-close: -1

package/.travis.yml

@@ -2,6 +2,7 @@ language: node_js
 node_js:
   - 10
   - 12
+  - 14
 before_install:
   # Create a master branch for commitlint
   # https://github.com/conventional-changelog/commitlint/issues/6
@@ -13,6 +14,7 @@ jobs:
       node_js:
         - 10
         - 12
+        - 14
       deploy:
         on:
           branch: master

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+# [4.2.0](https://github.com/americanexpress/jest-image-snapshot/compare/v4.1.0...v4.2.0) (2020-08-29)
+
+
+### Features
+
+* add obsolete snapshot reporting ([#222](https://github.com/americanexpress/jest-image-snapshot/issues/222)) ([47da7c2](https://github.com/americanexpress/jest-image-snapshot/commit/47da7c23495037e869ee68154218e5d73e1e8cd5))
+
+# [4.1.0](https://github.com/americanexpress/jest-image-snapshot/compare/v4.0.2...v4.1.0) (2020-07-23)
+
+
+### Features
+
+* **ssim:** add integration ([#220](https://github.com/americanexpress/jest-image-snapshot/issues/220)) ([e2b304a](https://github.com/americanexpress/jest-image-snapshot/commit/e2b304a6c6aaf7e1d12c2e088105181ee108b960))
+
+## [4.0.2](https://github.com/americanexpress/jest-image-snapshot/compare/v4.0.1...v4.0.2) (2020-05-27)
+
+
+### Bug Fixes
+
+* **options:** auto-detect colors if noColors option is not specified ([d90298c](https://github.com/americanexpress/jest-image-snapshot/commit/d90298c3f102734107a7574ddf0516c19a349c66))
+
+## [4.0.1](https://github.com/americanexpress/jest-image-snapshot/compare/v4.0.0...v4.0.1) (2020-05-27)
+
+
+### Bug Fixes
+
+* **options:** add allowSizeMismatch arg ([6529ff4](https://github.com/americanexpress/jest-image-snapshot/commit/6529ff4b2bd9a20abe33d4b68d9d793198931f18))
+
 # [4.0.0](https://github.com/americanexpress/jest-image-snapshot/compare/v3.1.0...v4.0.0) (2020-05-14)
 
 

package/README.md

@@ -100,14 +100,18 @@ See [the examples](./examples/README.md) for more detailed usage or read about a
 
 `toMatchImageSnapshot()` takes an optional options object with the following properties:
 
-* `customDiffConfig`: Custom config passed to [pixelmatch](https://github.com/mapbox/pixelmatch#pixelmatchimg1-img2-output-width-height-options) (See options section)
-  * By default we have set the `threshold` to 0.01, you can increase that value by passing a customDiffConfig as demonstrated below.
-  * Please note the `threshold` set in the `customDiffConfig` is the per pixel sensitivity threshold. For example with a source pixel colour of `#ffffff` (white) and a comparison pixel colour of `#fcfcfc` (really light grey) if you set the threshold to 0 then it would trigger a failure *on that pixel*. However if you were to use say 0.5 then it wouldn't, the colour difference would need to be much more extreme to trigger a failure on that pixel, say `#000000` (black)
+* `customDiffConfig`: Custom config passed to [pixelmatch](https://github.com/mapbox/pixelmatch#pixelmatchimg1-img2-output-width-height-options) (See options section) or [ssim.js](https://github.com/obartra/ssim/wiki/Usage#options)
+  * Pixelmatch specific options
+    * By default we have set the `threshold` to 0.01, you can increase that value by passing a customDiffConfig as demonstrated below.
+    * Please note the `threshold` set in the `customDiffConfig` is the per pixel sensitivity threshold. For example with a source pixel colour of `#ffffff` (white) and a comparison pixel colour of `#fcfcfc` (really light grey) if you set the threshold to 0 then it would trigger a failure *on that pixel*. However if you were to use say 0.5 then it wouldn't, the colour difference would need to be much more extreme to trigger a failure on that pixel, say `#000000` (black)
+  * SSIM specific options
+    * By default we set `ssim` to 'bezkrovny'.  It is the fastest option and best option most of the time.  In cases where, higher precision is needed,  this can be set to 'fast'.  See [SSIM Performance Consideration](#ssim-performance-considerations) for a better understanding of how to use this feature.
+* `comparisonMethod`: (default: `pixelmatch`) (options `pixelmatch` or `ssim`) The method by which images are compared.  `pixelmatch` does a pixel by pixel comparison, whereas `ssim` does a structural similarity comparison.  `ssim` is a new experimental feature for jest-image-snapshot, but may become the default comparison method in the future.  For a better understanding of how to use SSIM, see [Recommendations when using SSIM Comparison](#recommendations-when-using-ssim-comparison).
 * `customSnapshotsDir`: A custom absolute path of a directory to keep this snapshot in
 * `customDiffDir`: A custom absolute path of a directory to keep this diff in
 * `customSnapshotIdentifier`: A custom name to give this snapshot. If not provided one is computed automatically. When a function is provided it is called with an object containing `testPath`, `currentTestName`, `counter` and `defaultIdentifier` as its first argument. The function must return an identifier to use for the snapshot.
 * `diffDirection`: (default: `horizontal`) (options `horizontal` or `vertical`) Changes diff image layout direction
-* `noColors`: (default `false`) Removes coloring from console output, useful if storing the results in a file
+* `noColors`: Removes coloring from console output, useful if storing the results in a file
 * `failureThreshold`: (default `0`) Sets the threshold that would trigger a test failure based on the `failureThresholdType` selected. This is different to the `customDiffConfig.threshold` above, that is the per pixel failure threshold, this is the failure threshold for the entire comparison.
 * `failureThresholdType`: (default `pixel`) (options `percent` or `pixel`) Sets the type of threshold that would trigger a failure.
 * `updatePassedSnapshot`: (default `false`) Updates a snapshot even if it passed the threshold against the existing one.
@@ -156,6 +160,66 @@ expect.extend({ toMatchImageSnapshot });
 ### jest.retryTimes()
 Jest supports [automatic retries on test failures](https://jestjs.io/docs/en/jest-object#jestretrytimes). This can be useful for browser screenshot tests which tend to have more frequent false positives. Note that when using jest.retryTimes you'll have to use a unique customSnapshotIdentifier as that's the only way to reliably identify snapshots.
 
+### Removing Outdated Snapshots
+
+Unlike jest-managed snapshots, the images created by `jest-image-snapshot` will not be automatically removed by the `-u` flag if they are no longer needed. You can force `jest-image-snapshot` to remove the files by including the `outdated-snapshot-reporter` in your config and running with the environment variable `JEST_IMAGE_SNAPSHOT_TRACK_OBSOLETE`.
+
+```json
+{
+  "jest": {
+    "reporters": [
+      "default",
+      "jest-image-snapshot/src/outdated-snapshot-reporter.js"
+    ]
+  }
+}
+```
+
+**WARNING: Do not run a *partial* test suite with this flag as it may consider snapshots of tests that weren't run to be obsolete.**
+
+```bash
+export JEST_IMAGE_SNAPSHOT_TRACK_OBSOLETE=1
+jest
+```
+
+### Recommendations when using SSIM comparison
+Since SSIM calculates differences in structural similarity by building a moving 'window' over an images pixels, it does not particularly benefit from pixel count comparisons, especially when you factor in that it has a lot of floating point arithmetic in javascript.  However, SSIM gains two key benefits over pixel by pixel comparison:
+- Reduced false positives (failing tests when the images look the same)
+- Higher sensitivity to actual changes in the image itself.
+
+Documentation supporting these claims can be found in the many analyses comparing SSIM to Peak Signal to Noise Ratio (PSNR).  See [Wang, Z.; Simoncelli, E. P. (September 2008). "Maximum differentiation (MAD) competition: a methodology for comparing computational models of perceptual quantities"](https://ece.uwaterloo.ca/~z70wang/publications/MAD.pdf) and  Zhang, L.; Zhang, L.; Mou, X.; Zhang, D. (September 2012). A comprehensive evaluation of full reference image quality assessment algorithms. 2012 19th IEEE International Conference on Image Processing. pp. 1477–1480.  [Wikipedia](http://en.wikipedia.org/wiki/Structural_Similarity) also provides many great reference sources describing the topic.
+
+As such, most users can benefit from setting a 1% or 0.01 threshold for any SSIM comparison. The below code shows a one line modification of the 1% threshold example.
+
+```javascript
+it('should fail if there is more than a 1% difference (ssim)', () => {
+  ...
+  expect(image).toMatchImageSnapshot({
+    comparisonMethod: 'ssim',
+    failureThreshold: 0.01,
+    failureThresholdType: 'percent'
+  });
+});
+```
+### SSIM Performance Considerations
+The default SSIM comparison method used in the jest-image-snapshot implementation is 'bezkrovny' (as a `customDiffConfig` `{ssim: 'bezkrovny'}`).
+Bezkrovny is a special implementation of SSIM that is optimized for speed at a small, almost inconsequential change in accuracy.  It gains this benefit by downsampling (or shrinking the original image) before performing the comparisons.
+This will provide the best combination of results and performance most of the time.  When the need arises where higher accuracy is desired at the expense of time or a higher quality diff image is needed for debugging,
+this option can be changed to `{ssim: 'fast'}`. This uses the original SSIM algorithm described in Wang, et al. 2004 on "Image Quality Assessment: From Error Visibility to Structural Similarity" (https://github.com/obartra/ssim/blob/master/assets/ssim.pdf) optimized for javascript.
+
+The following is an example configuration for using `{ssim: 'fast'}` with toMatchImageSnapshot().
+```javascript.
+{
+  comparisonMethod: 'ssim',
+  customDiffConfig: {
+    ssim: 'fast',
+  },
+  failureThreshold: 0.01,
+  failureThresholdType: 'percent'
+}
+```
+
+
 ### Recipes
 
 #### Upload diff images from failed tests
@@ -172,9 +236,12 @@ To enable this image reporter, add it to your `jest.config.js` "reporters" defin
 
 #### Usage in TypeScript
 
-In TypeScript, you can declare `toMatchImageSnapshot` like this:
+In TypeScript, you can use the [DefinitelyTyped](https://www.npmjs.com/package/@types/jest-image-snapshot) definition or declare `toMatchImageSnapshot` like the example below:
 
-```
+_Note: This package is not maintained by the `jest-image-snapshot` maintainers so it may be out of date or inaccurate. Because of this, we do not officially support it._
+
+
+```typescript
 declare global {
   namespace jest {
     interface Matchers<R> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-image-snapshot",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "Jest matcher for image comparisons. Most commonly used for visual regression testing.",
   "main": "src/index.js",
   "engines": {
@@ -48,16 +48,16 @@
     "@commitlint/config-conventional": "^8.3.4",
     "@semantic-release/changelog": "^5.0.0",
     "@semantic-release/git": "^9.0.0",
-    "amex-jest-preset": "^6.0.1",
+    "amex-jest-preset": "^6.1.0",
     "eslint": "^6.8.0",
     "eslint-config-amex": "^7.0.0",
     "husky": "^4.2.1",
     "image-size": "^0.8.3",
     "jest": "^26.0.1",
     "jest-snapshot": "^26.0.1",
-    "semantic-release": "^17.0.4",
     "lockfile-lint": "^4.0.0",
-    "mock-spawn": "^0.2.6"
+    "mock-spawn": "^0.2.6",
+    "semantic-release": "^17.0.4"
   },
   "dependencies": {
     "chalk": "^1.1.3",
@@ -67,7 +67,8 @@
     "mkdirp": "^0.5.1",
     "pixelmatch": "^5.1.0",
     "pngjs": "^3.4.0",
-    "rimraf": "^2.6.2"
+    "rimraf": "^2.6.2",
+    "ssim.js": "^3.1.1"
   },
   "peerDependencies": {
     "jest": ">=20 <=26"

package/src/diff-snapshot.js

@@ -17,6 +17,7 @@ const fs = require('fs');
 const path = require('path');
 const mkdirp = require('mkdirp');
 const pixelmatch = require('pixelmatch');
+const ssim = require('ssim.js');
 const { PNG } = require('pngjs');
 const rimraf = require('rimraf');
 const glur = require('glur');
@@ -51,6 +52,74 @@ const fillSizeDifference = (width, height) => (image) => {
   return image;
 };
 /* eslint-enabled */
+/**
+ * This was originally embedded in diffImageToSnapshot
+ * when it only worked with pixelmatch.  It has a default
+ * threshold of 0.01 defined in terms of what it means to pixelmatch.
+ * It has been moved here as part of the SSIM implementation to make it
+ * a little easier to read and find.
+ * More information about this can be found under the options section listed
+ * in https://github.com/mapbox/pixelmatch/README.md and in the original pixelmatch
+ * code.  There is also some documentation on this in our README.md under the
+ * customDiffConfig option.
+ * @type {{threshold: number}}
+ */
+const defaultPixelmatchDiffConfig = {
+  threshold: 0.01,
+};
+/**
+ * This is the default SSIM diff configuration
+ * for the jest-image-snapshot's use of the ssim.js
+ * library.  Bezkrovny is a specific SSIM algorithm optimized
+ * for speed by downsampling the origin image into a smaller image.
+ * For the small loss in precision, it is roughly 9x faster than the
+ * SSIM preset 'fast' -- which is modeled after the original SSIM whitepaper.
+ * Wang, et al. 2004 on "Image Quality Assessment: From Error Visibility to Structural Similarity"
+ * (https://github.com/obartra/ssim/blob/master/assets/ssim.pdf)
+ * Most users will never need or want to change this -- unless --
+ * they want to get a better quality generated diff.
+ * @type {{ssim: string}}
+ */
+const defaultSSIMDiffConfig = { ssim: 'bezkrovny' };
+
+/**
+ * Helper function for SSIM comparison that allows us to use the existing diff
+ * config that works with jest-image-snapshot to pass parameters
+ * that will work with SSIM.  It also transforms the parameters to match the spec
+ * required by the SSIM library.
+ */
+const ssimMatch = (
+  newImageData,
+  baselineImageData,
+  diffImageData,
+  imageWidth,
+  imageHeight,
+  diffConfig
+) => {
+  const newImage = { data: newImageData, width: imageWidth, height: imageHeight };
+  const baselineImage = { data: baselineImageData, width: imageWidth, height: imageHeight };
+  // eslint-disable-next-line camelcase
+  const { ssim_map, mssim } = ssim.ssim(newImage, baselineImage, diffConfig);
+  // Converts the SSIM value to different pixels based on image width and height
+  // conforms to how pixelmatch works.
+  const diffPixels = (1 - mssim) * imageWidth * imageHeight;
+  const diffRgbaPixels = new DataView(diffImageData.buffer, diffImageData.byteOffset);
+  for (let ln = 0; ln !== imageHeight; ++ln) {
+    for (let pos = 0; pos !== imageWidth; ++pos) {
+      const rpos = (ln * imageWidth) + pos;
+      // initial value is transparent.  We'll add in the SSIM offset.
+      // red (ff) green (00) blue (00) alpha (00)
+      const diffValue = 0xff000000 + Math.floor(0xff *
+        (1 - ssim_map.data[
+          // eslint-disable-next-line no-mixed-operators
+          (ssim_map.width * Math.round(ssim_map.height * ln / imageHeight)) +
+          // eslint-disable-next-line no-mixed-operators
+          Math.round(ssim_map.width * pos / imageWidth)]));
+      diffRgbaPixels.setUint32(rpos * 4, diffValue);
+    }
+  }
+  return diffPixels;
+};
 
 /**
  * Aligns images sizes to biggest common value
@@ -129,8 +198,10 @@ function diffImageToSnapshot(options) {
     failureThresholdType,
     blur,
     allowSizeMismatch = false,
+    comparisonMethod = 'pixelmatch',
   } = options;
 
+  const comparisonFn = comparisonMethod === 'ssim' ? ssimMatch : pixelmatch;
   let result = {};
   const baselineSnapshotPath = path.join(snapshotsDir, `${snapshotIdentifier}-snap.png`);
   if (!fs.existsSync(baselineSnapshotPath)) {
@@ -141,9 +212,7 @@ function diffImageToSnapshot(options) {
     const diffOutputPath = path.join(diffDir, `${snapshotIdentifier}-diff.png`);
     rimraf.sync(diffOutputPath);
 
-    const defaultDiffConfig = {
-      threshold: 0.01,
-    };
+    const defaultDiffConfig = comparisonMethod !== 'ssim' ? defaultPixelmatchDiffConfig : defaultSSIMDiffConfig;
 
     const diffConfig = Object.assign({}, defaultDiffConfig, customDiffConfig);
 
@@ -175,7 +244,7 @@ function diffImageToSnapshot(options) {
 
     let diffPixelCount = 0;
 
-    diffPixelCount = pixelmatch(
+    diffPixelCount = comparisonFn(
       receivedImage.data,
       baselineImage.data,
       diffImage.data,

package/src/index.js

@@ -18,6 +18,7 @@ const path = require('path');
 const Chalk = require('chalk').constructor;
 const { diffImageToSnapshot, runDiffImageToSnapshot } = require('./diff-snapshot');
 const fs = require('fs');
+const OutdatedSnapshotReporter = require('./outdated-snapshot-reporter');
 
 const timesCalled = new Map();
 
@@ -37,6 +38,7 @@ function checkResult({
   snapshotIdentifier,
   chalk,
   dumpDiffToConsole,
+  allowSizeMismatch,
 }) {
   let pass = true;
   /*
@@ -65,7 +67,7 @@ function checkResult({
       const differencePercentage = result.diffRatio * 100;
       message = () => {
         let failure;
-        if (result.diffSize) {
+        if (result.diffSize && !allowSizeMismatch) {
           failure = `Expected image to be the same size as the snapshot (${result.imageDimensions.baselineWidth}x${result.imageDimensions.baselineHeight}), but was different (${result.imageDimensions.receivedWidth}x${result.imageDimensions.receivedHeight}).\n`;
         } else {
           failure = `Expected image to match or be a close match to snapshot but was ${differencePercentage}% different from snapshot (${result.diffPixelCount} differing pixels).\n`;
@@ -127,13 +129,15 @@ function configureToMatchImageSnapshot({
   customSnapshotsDir: commonCustomSnapshotsDir,
   customDiffDir: commonCustomDiffDir,
   diffDirection: commonDiffDirection = 'horizontal',
-  noColors: commonNoColors = false,
+  noColors: commonNoColors,
   failureThreshold: commonFailureThreshold = 0,
   failureThresholdType: commonFailureThresholdType = 'pixel',
   updatePassedSnapshot: commonUpdatePassedSnapshot = false,
   blur: commonBlur = 0,
   runInProcess: commonRunInProcess = false,
   dumpDiffToConsole: commonDumpDiffToConsole = false,
+  allowSizeMismatch: commonAllowSizeMismatch = false,
+  comparisonMethod: commonComparisonMethod = 'pixelmatch',
 } = {}) {
   return function toMatchImageSnapshot(received, {
     customSnapshotIdentifier = commonCustomSnapshotIdentifier,
@@ -148,11 +152,17 @@ function configureToMatchImageSnapshot({
     blur = commonBlur,
     runInProcess = commonRunInProcess,
     dumpDiffToConsole = commonDumpDiffToConsole,
+    allowSizeMismatch = commonAllowSizeMismatch,
+    comparisonMethod = commonComparisonMethod,
   } = {}) {
     const {
       testPath, currentTestName, isNot, snapshotState,
     } = this;
-    const chalk = new Chalk({ enabled: !noColors });
+    const chalkOptions = {};
+    if (typeof noColors !== 'undefined') {
+      chalkOptions.enabled = !noColors;
+    }
+    const chalk = new Chalk(chalkOptions);
 
     const retryTimes = parseInt(global[Symbol.for('RETRY_TIMES')], 10) || 0;
 
@@ -171,6 +181,7 @@ function configureToMatchImageSnapshot({
     const snapshotsDir = customSnapshotsDir || path.join(path.dirname(testPath), SNAPSHOTS_DIR);
     const diffDir = customDiffDir || path.join(snapshotsDir, '__diff_output__');
     const baselineSnapshotPath = path.join(snapshotsDir, `${snapshotIdentifier}-snap.png`);
+    OutdatedSnapshotReporter.markTouchedFile(baselineSnapshotPath);
 
     if (snapshotState._updateSnapshot === 'none' && !fs.existsSync(baselineSnapshotPath)) {
       return {
@@ -196,6 +207,8 @@ function configureToMatchImageSnapshot({
         failureThresholdType,
         updatePassedSnapshot,
         blur,
+        allowSizeMismatch,
+        comparisonMethod,
       });
 
     return checkResult({
@@ -205,6 +218,7 @@ function configureToMatchImageSnapshot({
       snapshotIdentifier,
       chalk,
       dumpDiffToConsole,
+      allowSizeMismatch,
     });
   };
 }

package/src/outdated-snapshot-reporter.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2020 American Express Travel Related Services Company, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/* eslint-disable class-methods-use-this */
+
+const fs = require('fs');
+const path = require('path');
+
+const TOUCHED_FILE_LIST_PATH = path.join(
+  process.cwd(),
+  '.jest-image-snapshot-touched-files'
+);
+
+const IS_ENABLED = !!process.env.JEST_IMAGE_SNAPSHOT_TRACK_OBSOLETE;
+
+class OutdatedSnapshotReporter {
+  /* istanbul ignore next - test coverage in child process */
+  static markTouchedFile(filePath) {
+    if (!IS_ENABLED) return;
+    const touchedListFileDescriptor = fs.openSync(TOUCHED_FILE_LIST_PATH, 'as');
+    fs.writeSync(touchedListFileDescriptor, `${filePath}\n`);
+    fs.closeSync(touchedListFileDescriptor);
+  }
+
+  /* istanbul ignore next - test coverage in child process */
+  static readTouchedFileListFromDisk() {
+    if (!fs.existsSync(TOUCHED_FILE_LIST_PATH)) return [];
+
+    return Array.from(
+      new Set(
+        fs
+          .readFileSync(TOUCHED_FILE_LIST_PATH, 'utf-8')
+          .split('\n')
+          .filter(file => file && fs.existsSync(file))
+      )
+    );
+  }
+
+  /* istanbul ignore next - test coverage in child process */
+  onRunStart() {
+    if (!IS_ENABLED) return;
+    if (fs.existsSync(TOUCHED_FILE_LIST_PATH)) {
+      fs.unlinkSync(TOUCHED_FILE_LIST_PATH);
+    }
+  }
+
+  /* istanbul ignore next - test coverage in child process */
+  onRunComplete() {
+    if (!IS_ENABLED) return;
+    const touchedFiles = OutdatedSnapshotReporter.readTouchedFileListFromDisk();
+    const imageSnapshotDirectories = Array.from(
+      new Set(touchedFiles.map(file => path.dirname(file)))
+    );
+    const allFiles = imageSnapshotDirectories
+      .map(dir => fs.readdirSync(dir).map(file => path.join(dir, file)))
+      .reduce((a, b) => a.concat(b), [])
+      .filter(file => file.endsWith('-snap.png'));
+    const obsoleteFiles = allFiles.filter(
+      file => !touchedFiles.includes(file)
+    );
+
+    if (fs.existsSync(TOUCHED_FILE_LIST_PATH)) {
+      fs.unlinkSync(TOUCHED_FILE_LIST_PATH);
+    }
+
+    obsoleteFiles.forEach((file) => {
+      process.stderr.write(`Deleting outdated snapshot "${file}"...\n`);
+      fs.unlinkSync(file);
+    });
+  }
+}
+
+module.exports = OutdatedSnapshotReporter;