fix: TestScheduler now take in count the runInBand config

packages/jest-cli/src/TestScheduler.js

@@ -29,8 +29,7 @@ import SummaryReporter from './reporters/summary_reporter';
 import TestRunner from 'jest-runner';
 import TestWatcher from './TestWatcher';
 import VerboseReporter from './reporters/verbose_reporter';
-
-const SLOW_TEST_TIME = 1000;
+import * as testSchedulerHelper from './testSchedulerHelper';
 
 // The default jest-runner is required because it is the default test runner
 // and required implicitly through the `runner` ProjectConfig option.
@@ -85,25 +84,12 @@ export default class TestScheduler {
       getEstimatedTime(timings, this._globalConfig.maxWorkers) / 1000,
     );
 
-    // Run in band if we only have one test or one worker available, unless we
-    // are using the watch mode, in which case the TTY has to be responsive and
-    // we cannot schedule anything in the main thread. Same logic applies to
-    // watchAll.
-    //
-    // If we are confident from previous runs that the tests will finish
-    // quickly we also run in band to reduce the overhead of spawning workers.
-    const areFastTests = timings.every(timing => timing < SLOW_TEST_TIME);
-
-    const runInBandWatch = tests.length <= 1 && areFastTests;
-    const runInBandNonWatch =
-      this._globalConfig.maxWorkers <= 1 ||
-      tests.length <= 1 ||
-      (tests.length <= 20 && timings.length > 0 && areFastTests);
-
-    const runInBand =
-      this._globalConfig.watch || this._globalConfig.watchAll
-        ? runInBandWatch
-        : runInBandNonWatch;
+    const runInBand = testSchedulerHelper.computeRunInBand(
+      tests,
+      this._globalConfig.watch || this._globalConfig.watchAll,
+      this._globalConfig.maxWorkers,
+      timings,
+    );
 
     const onResult = async (test: Test, testResult: TestResult) => {
       if (watcher.isInterrupted()) {

packages/jest-cli/src/__tests__/TestScheduler.test.js

@@ -10,6 +10,7 @@
 
 import TestScheduler from '../TestScheduler';
 import SummaryReporter from '../reporters/summary_reporter';
+import * as testSchedulerHelper from '../testSchedulerHelper';
 
 jest.mock('../reporters/default_reporter');
 const mockSerialRunner = {
@@ -27,8 +28,12 @@ jest.mock('jest-runner-parallel', () => jest.fn(() => mockParallelRunner), {
   virtual: true,
 });
 
+const spyComputeRunInBand = jest.spyOn(testSchedulerHelper, 'computeRunInBand');
+
 beforeEach(() => {
   mockSerialRunner.runTests.mockClear();
+  mockParallelRunner.runTests.mockClear();
+  spyComputeRunInBand.mockClear();
 });
 
 test('config for reporters supports `default`', () => {
@@ -180,3 +185,51 @@ test('should not bail if less than `n` failures', async () => {
   });
   expect(setState).not.toBeCalled();
 });
+
+test('should compute runInBand to run in serial', async () => {
+  const scheduler = new TestScheduler({}, {});
+  const test = {
+    context: {
+      config: {
+        runner: 'jest-runner-parallel',
+      },
+      hasteFS: {
+        matchFiles: jest.fn(() => []),
+      },
+    },
+    path: './test/path.js',
+  };
+  const tests = [test, test];
+
+  spyComputeRunInBand.mockReturnValue(true);
+
+  await scheduler.scheduleTests(tests, {isInterrupted: jest.fn()});
+
+  expect(spyComputeRunInBand).toHaveBeenCalled();
+  expect(mockParallelRunner.runTests).toHaveBeenCalled();
+  expect(mockParallelRunner.runTests.mock.calls[0][5].serial).toBeTruthy();
+});
+
+test('should compute runInBand to not run in serial', async () => {
+  const scheduler = new TestScheduler({}, {});
+  const test = {
+    context: {
+      config: {
+        runner: 'jest-runner-parallel',
+      },
+      hasteFS: {
+        matchFiles: jest.fn(() => []),
+      },
+    },
+    path: './test/path.js',
+  };
+  const tests = [test, test];
+
+  spyComputeRunInBand.mockReturnValue(false);
+
+  await scheduler.scheduleTests(tests, {isInterrupted: jest.fn()});
+
+  expect(spyComputeRunInBand).toHaveBeenCalled();
+  expect(mockParallelRunner.runTests).toHaveBeenCalled();
+  expect(mockParallelRunner.runTests.mock.calls[0][5].serial).toBeFalsy();
+});

packages/jest-cli/src/__tests__/testSchedulerHelper.test.js

@@ -0,0 +1,96 @@
+/**
+ * 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.
+ */
+'use strict';
+
+import {computeRunInBand} from '../testSchedulerHelper';
+
+const getTestMock = () => ({
+  context: {
+    config: {
+      runner: 'jest-runner-parallel',
+    },
+    hasteFS: {
+      matchFiles: jest.fn(() => []),
+    },
+  },
+  path: './test/path.js',
+});
+
+const getTestsMock = () => [getTestMock(), getTestMock()];
+
+describe('computeRunInBand()', () => {
+  describe('watch mode enabled', () => {
+    test('fast tests and only one test', () => {
+      expect(
+        computeRunInBand([getTestMock()], true, undefined, [500, 500]),
+      ).toBeTruthy();
+    });
+
+    // This apply also when runInBand arg present
+    // https://github.com/facebook/jest/blob/700e0dadb85f5dc8ff5dac6c7e98956690049734/packages/jest-config/src/getMaxWorkers.js#L14-L17
+    test('one worker only', () => {
+      expect(
+        computeRunInBand(getTestsMock(), true, 1, [2000, 500]),
+      ).toBeTruthy();
+    });
+
+    test('more than one worker', () => {
+      expect(
+        computeRunInBand(getTestsMock(), true, 2, [2000, 500]),
+      ).toBeFalsy();
+    });
+
+    test('slow tests', () => {
+      expect(
+        computeRunInBand([getTestMock()], true, undefined, [2000, 500]),
+      ).toBeFalsy();
+    });
+
+    test('more than one test', () => {
+      expect(
+        computeRunInBand(getTestsMock(), true, undefined, [500, 500]),
+      ).toBeFalsy();
+    });
+  });
+
+  describe('watch mode disabled', () => {
+    test('one worker only', () => {
+      expect(
+        computeRunInBand(getTestsMock(), false, 1, [2000, 500]),
+      ).toBeTruthy();
+    });
+
+    test('more than one worker', () => {
+      expect(
+        computeRunInBand(getTestsMock(), false, 2, [2000, 500]),
+      ).toBeFalsy();
+    });
+
+    test('one test only', () => {
+      expect(
+        computeRunInBand([getTestMock()], false, undefined, [2000]),
+      ).toBeTruthy();
+    });
+
+    test('fast tests and less than 20', () => {
+      expect(
+        computeRunInBand(getTestsMock(), false, undefined, [500, 500]),
+      ).toBeTruthy();
+    });
+
+    test('too much tests more than 20', () => {
+      const tests = new Array(45);
+      expect(computeRunInBand(tests, false, undefined, [500])).toBeFalsy();
+    });
+
+    test('slow tests', () => {
+      expect(
+        computeRunInBand(getTestsMock(), false, undefined, [2000, 500]),
+      ).toBeFalsy();
+    });
+  });
+});

packages/jest-cli/src/testSchedulerHelper.js

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ */
+'use strict';
+
+const SLOW_TEST_TIME = 1000;
+
+export function computeRunInBand(tests, isWatchMode, maxWorkers, timings) {
+  // Run in band if we only have one test or one worker available, unless we
+  // are using the watch mode, in which case the TTY has to be responsive and
+  // we cannot schedule anything in the main thread. Same logic applies to
+  // watchAll.
+  //
+  // If we are confident from previous runs that the tests will finish
+  // quickly we also run in band to reduce the overhead of spawning workers.
+  const areFastTests = timings.every(timing => timing < SLOW_TEST_TIME);
+
+  const oneWorkerOrLess = maxWorkers <= 1;
+  const oneTestOrLess = tests.length <= 1;
+
+  if (isWatchMode) {
+    return oneWorkerOrLess || (oneTestOrLess && areFastTests);
+  }
+
+  return (
+    oneWorkerOrLess ||
+    oneTestOrLess ||
+    (tests.length <= 20 && timings.length > 0 && areFastTests)
+  );
+}