Make jest-haste-map compute SHA-1s for excluded files too (as watchma…

…n does) (#6264)

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 * `[expect]` toMatchObject throws TypeError when a source property is null ([#6313](https://github.com/facebook/jest/pull/6313))
 * `[jest-cli]` Normalize slashes in paths in CLI output on Windows ([#6310](https://github.com/facebook/jest/pull/6310))
+* `[jest-haste-map`] Compute SHA-1s for non-tracked files when using Node crawler ([#6264](https://github.com/facebook/jest/pull/6264))
 
 ### Chore & Maintenance
 

e2e/__tests__/haste_map_sha1.test.js

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+'use strict';
+
+import os from 'os';
+import path from 'path';
+import JestHasteMap from 'jest-haste-map';
+const {cleanup, writeFiles} = require('../Utils');
+
+const DIR = path.resolve(os.tmpdir(), 'haste_map_sha1');
+
+beforeEach(() => cleanup(DIR));
+afterEach(() => cleanup(DIR));
+
+test('exits the process after test are done but before timers complete', async () => {
+  writeFiles(DIR, {
+    'file.android.js': '"foo android"',
+    'file.ios.js': '"foo ios"',
+    'file.js': '"foo default"',
+    'file_with_extension.ignored': '"ignored file"',
+    'node_modules/bar/file_with_extension.ignored': '"ignored node modules"',
+    'node_modules/bar/image.png': '"an image"',
+    'node_modules/bar/index.js': '"node modules bar"',
+  });
+
+  const haste = new JestHasteMap({
+    computeSha1: true,
+    extensions: ['js', 'json', 'png'],
+    forceNodeFilesystemAPI: true,
+    ignorePattern: / ^/,
+    maxWorkers: 2,
+    mocksPattern: '',
+    name: 'tmp',
+    platforms: ['ios', 'android'],
+    retainAllFiles: true,
+    roots: [DIR],
+    useWatchman: false,
+    watch: false,
+  });
+
+  const {hasteFS} = await haste.build();
+
+  expect(hasteFS.getSha1(path.join(DIR, 'file.android.js'))).toBe(
+    'e376f9fd9a96d000fa019020159f996a8855f8bc',
+  );
+
+  expect(hasteFS.getSha1(path.join(DIR, 'file.ios.js'))).toBe(
+    '1271b4db2a5f47ae46cb01a1d0604a94d401e8f7',
+  );
+
+  expect(hasteFS.getSha1(path.join(DIR, 'file.js'))).toBe(
+    'c26c852220977244418f17a9fdc4ae9c192b3188',
+  );
+
+  expect(hasteFS.getSha1(path.join(DIR, 'node_modules/bar/image.png'))).toBe(
+    '8688f7e11f63d8a7eac7cb87af850337fabbd400',
+  );
+
+  expect(hasteFS.getSha1(path.join(DIR, 'node_modules/bar/index.js'))).toBe(
+    'ee245b9fbd45e1f6ad300eb2f5484844f6b5a34c',
+  );
+
+  // Ignored files do not get the SHA-1 computed.
+
+  expect(hasteFS.getSha1(path.join(DIR, 'file_with_extension.ignored'))).toBe(
+    null,
+  );
+
+  expect(
+    hasteFS.getSha1(
+      path.join(DIR, 'node_modules/bar/file_with_extension.ignored'),
+    ),
+  ).toBe(null);
+});

packages/jest-haste-map/src/__tests__/worker.test.js

@@ -14,7 +14,7 @@ import ConditionalTest from '../../../../scripts/ConditionalTest';
 
 import H from '../constants';
 
-const {worker} = require('../worker');
+const {worker, getSha1} = require('../worker');
 
 let mockFs;
 let readFileSync;
@@ -47,10 +47,8 @@ describe('worker', () => {
 
     readFileSync = fs.readFileSync;
     fs.readFileSync = jest.fn((path, options) => {
-      expect(options).toBe('utf8');
-
       if (mockFs[path]) {
-        return mockFs[path];
+        return options === 'utf8' ? mockFs[path] : Buffer.from(mockFs[path]);
       }
 
       throw new Error(`Cannot read path '${path}'.`);
@@ -109,4 +107,22 @@ describe('worker', () => {
 
     expect(error.message).toEqual(`Cannot read path '/kiwi.js'.`);
   });
+
+  it('simply computes SHA-1s when requested', async () => {
+    expect(
+      await getSha1({computeSha1: false, filePath: '/fruits/banana.js'}),
+    ).toEqual({sha1: null});
+
+    expect(
+      await getSha1({computeSha1: true, filePath: '/fruits/banana.js'}),
+    ).toEqual({sha1: 'f24c6984cce6f032f6d55d771d04ab8dbbe63c8c'});
+
+    expect(
+      await getSha1({computeSha1: true, filePath: '/fruits/pear.js'}),
+    ).toEqual({sha1: '1bf6fc618461c19553e27f8b8021c62b13ff614a'});
+
+    await expect(
+      getSha1({computeSha1: true, filePath: '/i/dont/exist.js'}),
+    ).rejects.toThrow();
+  });
 });

packages/jest-haste-map/src/index.js

@@ -9,7 +9,7 @@
 
 import {execSync} from 'child_process';
 import {version as VERSION} from '../package.json';
-import {worker} from './worker';
+import {getSha1, worker} from './worker';
 import crypto from 'crypto';
 import EventEmitter from 'events';
 import getMockName from './get_mock_name';
@@ -86,7 +86,7 @@ type Watcher = {
   close(callback: () => void): void,
 };
 
-type WorkerInterface = {worker: typeof worker};
+type WorkerInterface = {worker: typeof worker, getSha1: typeof getSha1};
 
 export type ModuleMap = HasteModuleMap;
 export type FS = HasteFS;
@@ -407,9 +407,60 @@ class HasteMap extends EventEmitter {
       moduleMap[platform] = module;
     };
 
+    const fileMetadata = hasteMap.files[filePath];
+    const moduleMetadata = hasteMap.map[fileMetadata[H.ID]];
+    const computeSha1 = this._options.computeSha1 && !fileMetadata[H.SHA1];
+
+    // Callback called when the response from the worker is successful.
+    const workerReply = metadata => {
+      // `1` for truthy values instead of `true` to save cache space.
+      fileMetadata[H.VISITED] = 1;
+
+      const metadataId = metadata.id;
+      const metadataModule = metadata.module;
+
+      if (metadataId && metadataModule) {
+        fileMetadata[H.ID] = metadataId;
+        setModule(metadataId, metadataModule);
+      }
+
+      fileMetadata[H.DEPENDENCIES] = metadata.dependencies || [];
+
+      if (computeSha1) {
+        fileMetadata[H.SHA1] = metadata.sha1;
+      }
+    };
+
+    // Callback called when the response from the worker is an error.
+    const workerError = error => {
+      if (typeof error !== 'object' || !error.message || !error.stack) {
+        error = new Error(error);
+        error.stack = ''; // Remove stack for stack-less errors.
+      }
+
+      // $FlowFixMe: checking error code is OK if error comes from "fs".
+      if (!['ENOENT', 'EACCES'].includes(error.code)) {
+        throw error;
+      }
+
+      // If a file cannot be read we remove it from the file list and
+      // ignore the failure silently.
+      delete hasteMap.files[filePath];
+    };
+
     // If we retain all files in the virtual HasteFS representation, we avoid
     // reading them if they aren't important (node_modules).
     if (this._options.retainAllFiles && this._isNodeModulesDir(filePath)) {
+      if (computeSha1) {
+        return this._getWorker(workerOptions)
+          .getSha1({
+            computeSha1,
+            filePath,
+            hasteImplModulePath: this._options.hasteImplModulePath,
+          })
+          .then(workerReply, workerError);
+      }
+
       return null;
     }
 
@@ -433,10 +484,6 @@ class HasteMap extends EventEmitter {
       mocks[mockPath] = filePath;
     }
 
-    const fileMetadata = hasteMap.files[filePath];
-    const moduleMetadata = hasteMap.map[fileMetadata[H.ID]];
-    const computeSha1 = this._options.computeSha1 && !fileMetadata[H.SHA1];
-
     if (fileMetadata[H.VISITED]) {
       if (!fileMetadata[H.ID]) {
         return null;
@@ -467,41 +514,7 @@ class HasteMap extends EventEmitter {
         filePath,
         hasteImplModulePath: this._options.hasteImplModulePath,
       })
-      .then(
-        metadata => {
-          // `1` for truthy values instead of `true` to save cache space.
-          fileMetadata[H.VISITED] = 1;
-
-          const metadataId = metadata.id;
-          const metadataModule = metadata.module;
-
-          if (metadataId && metadataModule) {
-            fileMetadata[H.ID] = metadataId;
-            setModule(metadataId, metadataModule);
-          }
-
-          fileMetadata[H.DEPENDENCIES] = metadata.dependencies || [];
-
-          if (computeSha1) {
-            fileMetadata[H.SHA1] = metadata.sha1;
-          }
-        },
-        error => {
-          if (typeof error !== 'object' || !error.message || !error.stack) {
-            error = new Error(error);
-            error.stack = ''; // Remove stack for stack-less errors.
-          }
-
-          // $FlowFixMe: checking error code is OK if error comes from "fs".
-          if (['ENOENT', 'EACCES'].indexOf(error.code) < 0) {
-            throw error;
-          }
-
-          // If a file cannot be read we remove it from the file list and
-          // ignore the failure silently.
-          delete hasteMap.files[filePath];
-        },
-      );
+      .then(workerReply, workerError);
   }
 
   _buildHasteMap(data: {
@@ -563,14 +576,14 @@ class HasteMap extends EventEmitter {
   _getWorker(options: ?{forceInBand: boolean}): WorkerInterface {
     if (!this._worker) {
       if ((options && options.forceInBand) || this._options.maxWorkers <= 1) {
-        this._worker = {worker};
+        this._worker = {getSha1, worker};
       } else {
         // $FlowFixMe: assignment of a worker with custom properties.
         this._worker = (new Worker(require.resolve('./worker'), {
-          exposedMethods: ['worker'],
+          exposedMethods: ['getSha1', 'worker'],
           maxRetries: 3,
           numWorkers: this._options.maxWorkers,
-        }): {worker: typeof worker});
+        }): WorkerInterface);
       }
     }
 

packages/jest-haste-map/src/worker.js

@@ -22,6 +22,13 @@ const PACKAGE_JSON = path.sep + 'package.json';
 let hasteImpl: ?HasteImpl = null;
 let hasteImplModulePath: ?string = null;
 
+function computeSha1(content) {
+  return crypto
+    .createHash('sha1')
+    .update(content)
+    .digest('hex');
+}
+
 export async function worker(data: WorkerMessage): Promise<WorkerMetadata> {
   if (
     data.hasteImplModulePath &&
@@ -76,11 +83,21 @@ export async function worker(data: WorkerMessage): Promise<WorkerMetadata> {
       content = fs.readFileSync(filePath);
     }
 
-    sha1 = crypto
-      .createHash('sha1')
-      .update(content)
-      .digest('hex');
+    sha1 = computeSha1(content);
   }
 
   return {dependencies, id, module, sha1};
 }
+
+export async function getSha1(data: WorkerMessage): Promise<WorkerMetadata> {
+  const sha1 = data.computeSha1
+    ? computeSha1(fs.readFileSync(data.filePath))
+    : null;
+
+  return {
+    dependencies: undefined,
+    id: undefined,
+    module: undefined,
+    sha1,
+  };
+}