Clear resolved modules cache before runJest in watch mode

e2e/__tests__/__snapshots__/moduleNameMapper.test.ts.snap

@@ -30,6 +30,6 @@ FAIL __tests__/index.js
       12 | module.exports = () => 'test';
       13 | 
 
-      at createNoMappedModuleFoundError (../../packages/jest-resolve/build/index.js:472:17)
+      at createNoMappedModuleFoundError (../../packages/jest-resolve/build/index.js:501:17)
       at Object.require (index.js:10:1)
 `;

e2e/__tests__/__snapshots__/resolveNoFileExtensions.test.ts.snap

@@ -33,6 +33,6 @@ FAIL __tests__/test.js
         |                  ^
       4 | 
 
-      at Resolver.resolveModule (../../packages/jest-resolve/build/index.js:230:17)
+      at Resolver.resolveModule (../../packages/jest-resolve/build/index.js:259:17)
       at Object.require (index.js:3:18)
 `;

packages/jest-core/package.json

@@ -19,6 +19,7 @@
     "jest-haste-map": "^24.8.0",
     "jest-message-util": "^24.8.0",
     "jest-regex-util": "^24.3.0",
+    "jest-resolve": "^24.8.0",
     "jest-resolve-dependencies": "^24.8.0",
     "jest-runner": "^24.8.0",
     "jest-runtime": "^24.8.0",

packages/jest-core/src/__tests__/watch-file-changes.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. 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.
+ *
+ */
+
+'use strict';
+
+import path from 'path';
+import fs from 'fs';
+import {JestHook} from 'jest-watcher';
+import Runtime from 'jest-runtime';
+import {normalize} from 'jest-config';
+import HasteMap from 'jest-haste-map';
+import {AggregatedResult} from '@jest/test-result';
+
+describe('Watch mode flows with changed files', () => {
+  let watch: any;
+  let pipe: NodeJS.ReadStream;
+  let stdin: MockStdin;
+  const fileTargetPath = path.resolve(
+    __dirname,
+    '__fixtures__',
+    'lost-file.js',
+  );
+  const fileTargetPath2 = path.resolve(
+    __dirname,
+    '__fixtures__',
+    'watch-test.test.js',
+  );
+  const cacheDirectory = path.resolve(__dirname, `tmp${Math.random()}`);
+  let hasteMapInstance: HasteMap;
+  const deleteFolderRecursive = pathname => {
+    if (fs.existsSync(pathname)) {
+      fs.readdirSync(pathname).forEach(file => {
+        const curPath = path.resolve(pathname, file);
+        if (fs.lstatSync(curPath).isDirectory()) {
+          // recurse
+          deleteFolderRecursive(curPath);
+        } else {
+          // delete file
+          fs.unlinkSync(curPath);
+        }
+      });
+      fs.rmdirSync(pathname);
+    }
+  };
+
+  beforeEach(() => {
+    watch = require('../watch').default;
+    pipe = {write: jest.fn()} as any;
+    stdin = new MockStdin();
+  });
+
+  afterEach(() => {
+    jest.resetModules();
+    hasteMapInstance.end();
+    [fileTargetPath2, fileTargetPath].forEach(file => {
+      try {
+        fs.unlinkSync(file);
+      } catch (e) {}
+    });
+    deleteFolderRecursive(cacheDirectory);
+  });
+
+  it('should correct require new files without legacy cache', async () => {
+    fs.writeFileSync(
+      fileTargetPath2,
+      `
+        require('${fileTargetPath}');
+        describe('Fake test', () => {
+            it('Hey', () => {  
+
+            });
+        });
+      `,
+      {
+        encoding: 'utf-8',
+      },
+    );
+
+    fs.mkdirSync(cacheDirectory);
+    const config = normalize(
+      {
+        automock: false,
+        cache: false,
+        cacheDirectory,
+        coverageReporters: [],
+        maxConcurrency: 1,
+        maxWorkers: 1,
+        moduleDirectories: ['node_modules'],
+        moduleFileExtensions: ['js', 'jsx', 'ts', 'tsx', 'json'],
+        modulePathIgnorePatterns: [],
+        onlyChanged: false,
+        reporters: [],
+        rootDir: __dirname,
+        roots: [__dirname],
+        silent: true,
+        testRegex: ['watch-test\\.test\\.js$'],
+        watch: false,
+        watchman: false,
+      },
+      {} as any,
+    ).options;
+
+    hasteMapInstance = await Runtime.createHasteMap(config, {
+      maxWorkers: 1,
+      resetCache: true,
+      watch: true,
+      watchman: false,
+    });
+
+    const realContext = await hasteMapInstance.build().then(
+      hasteMap => ({
+        config,
+        hasteFS: hasteMap.hasteFS,
+        moduleMap: hasteMap.moduleMap,
+        resolver: Runtime.createResolver(config, hasteMap.moduleMap),
+      }),
+      error => {
+        throw error;
+      },
+    );
+
+    const hook = new JestHook();
+    await watch(
+      {
+        ...config,
+        watchPlugins: [],
+      },
+      [realContext],
+      pipe,
+      [hasteMapInstance],
+      stdin,
+      hook,
+    );
+
+    await new Promise(resolve => {
+      hook.getSubscriber().onTestRunComplete(resolve);
+    });
+
+    // Create lost file
+    fs.writeFileSync(
+      fileTargetPath,
+      `
+        describe('Fake group', () => {
+            it('Fake 1', () => {});
+            it('Fake 2', () => {});
+            it('Fake 3', () => {});
+        });
+      `,
+      {encoding: 'utf-8'},
+    );
+
+    const resultSuccessReport: AggregatedResult = await new Promise(resolve => {
+      hook.getSubscriber().onTestRunComplete(resolve);
+    });
+
+    expect(resultSuccessReport).toMatchObject({
+      numFailedTestSuites: 0,
+      numFailedTests: 0,
+      numPassedTests: 4,
+      numRuntimeErrorTestSuites: 0,
+      success: true,
+      wasInterrupted: false,
+    });
+    expect(resultSuccessReport.testResults[0]).toMatchObject({
+      failureMessage: null,
+    });
+
+    // Remove again to ensure about no legacy cache
+    fs.unlinkSync(fileTargetPath);
+
+    const resultErrorReport: AggregatedResult = await new Promise(resolve => {
+      hook.getSubscriber().onTestRunComplete(resolve);
+    });
+
+    // After remove file we have to fail tests
+    expect(resultErrorReport).toMatchObject({
+      numFailedTestSuites: 1,
+      numPassedTests: 0,
+      numRuntimeErrorTestSuites: 1,
+      success: false,
+      wasInterrupted: false,
+    });
+  });
+});
+
+class MockStdin {
+  private _callbacks: Array<any>;
+
+  constructor() {
+    this._callbacks = [];
+  }
+
+  resume() {}
+
+  setEncoding() {}
+
+  on(_: any, callback: any) {
+    this._callbacks.push(callback);
+  }
+
+  emit(key: string) {
+    this._callbacks.forEach(cb => cb(key));
+  }
+}

packages/jest-core/src/watch.ts

@@ -15,6 +15,7 @@ import {formatExecError} from 'jest-message-util';
 import {isInteractive, preRunMessage, specialChars} from 'jest-util';
 import {ValidationError} from 'jest-validate';
 import {Context} from 'jest-runtime';
+import Resolver from 'jest-resolve';
 import {Config} from '@jest/types';
 import {
   AllowedConfigOptions,
@@ -275,6 +276,9 @@ export default function watch(
     isRunning = true;
     const configs = contexts.map(context => context.config);
     const changedFilesPromise = getChangedFilesPromise(globalConfig, configs);
+    // Clear cache for required modules
+    Resolver.clearDefaultResolverCache();
+
     return runJest({
       changedFilesPromise,
       contexts,

packages/jest-resolve/src/defaultResolver.ts

@@ -44,6 +44,10 @@ export default function defaultResolver(
   });
 }
 
+export const clearDefaultResolverCache = () => {
+  checkedPaths.clear();
+};
+
 const REGEX_RELATIVE_IMPORT = /^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[\\\/])/;
 
 function resolveSync(

packages/jest-resolve/src/index.ts

@@ -12,7 +12,7 @@ import {sync as realpath} from 'realpath-native';
 import chalk from 'chalk';
 import nodeModulesPaths from './nodeModulesPaths';
 import isBuiltinModule from './isBuiltinModule';
-import defaultResolver from './defaultResolver';
+import defaultResolver, {clearDefaultResolverCache} from './defaultResolver';
 import {ResolverConfig} from './types';
 
 type FindNodeModuleConfig = {
@@ -79,6 +79,10 @@ class Resolver {
     this._modulePathCache = new Map();
   }
 
+  static clearDefaultResolverCache() {
+    clearDefaultResolverCache();
+  }
+
   static findNodeModule(
     path: Config.Path,
     options: FindNodeModuleConfig,