Lint fixes

e2e/__tests__/test_retries.test.js

@@ -40,7 +40,7 @@ describe('Test Retries', () => {
 
  const reporterConfig = {
  reporters: [
- ['<rootDir>/reporters/RetryReporter.js', { output: outputFilePath }],
+ ['<rootDir>/reporters/RetryReporter.js', {output: outputFilePath}],
  ],
  };
 
@@ -71,7 +71,7 @@ describe('Test Retries', () => {
 
  const reporterConfig = {
  reporters: [
- ['<rootDir>/reporters/RetryReporter.js', { output: outputFilePath }],
+ ['<rootDir>/reporters/RetryReporter.js', {output: outputFilePath}],
  ],
  };
 

packages/jest-circus/src/run.js

@@ -9,13 +9,13 @@
 
 import type {
  RunResult,
-  TestEntry,
-  TestContext,
-  Hook,
-  DescribeBlock,
+ TestEntry,
+ TestContext,
+ Hook,
+ DescribeBlock,
 } from 'types/Circus';
 
-import { getState, dispatch } from './state';
+import {getState, dispatch} from './state';
 import {
  callAsyncFn,
  getAllHooksForDescribe,
@@ -29,22 +29,22 @@ import {
 const Promise = getOriginalPromise();
 
 const run = async (): Promise<RunResult> => {
- const { rootDescribeBlock } = getState();
- dispatch({ name: 'run_start' });
+ const {rootDescribeBlock} = getState();
+ dispatch({name: 'run_start'});
  await _runTestsForDescribeBlock(rootDescribeBlock);
- dispatch({ name: 'run_finish' });
+ dispatch({name: 'run_finish'});
  return makeRunResult(
  getState().rootDescribeBlock,
  getState().unhandledErrors,
  );
 };
 
 const _runTestsForDescribeBlock = async (describeBlock: DescribeBlock) => {
- dispatch({ describeBlock, name: 'run_describe_start' });
- const { beforeAll, afterAll } = getAllHooksForDescribe(describeBlock);
+ dispatch({describeBlock, name: 'run_describe_start'});
+ const {beforeAll, afterAll} = getAllHooksForDescribe(describeBlock);
 
  for (const hook of beforeAll) {
- await _callHook({ describeBlock, hook });
+ await _callHook({describeBlock, hook});
  }
 
  // Tests that fail and are retried we run after other tests
@@ -78,47 +78,47 @@ const _runTestsForDescribeBlock = async (describeBlock: DescribeBlock) => {
  }
 
  for (const hook of afterAll) {
- await _callHook({ describeBlock, hook });
+ await _callHook({describeBlock, hook});
  }
- dispatch({ describeBlock, name: 'run_describe_finish' });
+ dispatch({describeBlock, name: 'run_describe_finish'});
 };
 
 const _runTest = async (test: TestEntry): Promise<void> => {
- dispatch({ name: 'test_start', test });
+ dispatch({name: 'test_start', test});
  const testContext = Object.create(null);
- const { hasFocusedTests, testNamePattern } = getState();
+ const {hasFocusedTests, testNamePattern} = getState();
 
  const isSkipped =
  test.mode === 'skip' ||
  (hasFocusedTests && test.mode !== 'only') ||
  (testNamePattern && !testNamePattern.test(getTestID(test)));
 
  if (isSkipped) {
- dispatch({ name: 'test_skip', test });
+ dispatch({name: 'test_skip', test});
  return;
  }
 
- const { afterEach, beforeEach } = getEachHooksForTest(test);
+ const {afterEach, beforeEach} = getEachHooksForTest(test);
 
  for (const hook of beforeEach) {
  if (test.errors.length) {
  // If any of the before hooks failed already, we don't run any
  // hooks after that.
  break;
  }
- await _callHook({ hook, test, testContext });
+ await _callHook({hook, test, testContext});
  }
 
  await _callTest(test, testContext);
 
  for (const hook of afterEach) {
- await _callHook({ hook, test, testContext });
+ await _callHook({hook, test, testContext});
  }
 
  // `afterAll` hooks should not affect test status (pass or fail), because if
  // we had a global `afterAll` hook it would block all existing tests until
  // this hook is executed. So we dispatche `test_done` right away.
- dispatch({ name: 'test_done', test });
+ dispatch({name: 'test_done', test});
 };
 
 const _callHook = ({
@@ -127,25 +127,25 @@ const _callHook = ({
  describeBlock,
  testContext,
 }: {
-  hook: Hook,
-  describeBlock?: DescribeBlock,
-  test?: TestEntry,
-  testContext?: TestContext,
- }): Promise<mixed> => {
- dispatch({ hook, name: 'hook_start' });
+ hook: Hook,
+ describeBlock?: DescribeBlock,
+ test?: TestEntry,
+ testContext?: TestContext,
+}): Promise<mixed> => {
+ dispatch({hook, name: 'hook_start'});
  const timeout = hook.timeout || getState().testTimeout;
- return callAsyncFn(hook.fn, testContext, { isHook: true, timeout })
- .then(() => dispatch({ describeBlock, hook, name: 'hook_success', test }))
+ return callAsyncFn(hook.fn, testContext, {isHook: true, timeout})
+ .then(() => dispatch({describeBlock, hook, name: 'hook_success', test}))
  .catch(error =>
- dispatch({ describeBlock, error, hook, name: 'hook_failure', test }),
- );
+ dispatch({describeBlock, error, hook, name: 'hook_failure', test}),
+  );
 };
 
 const _callTest = async (
  test: TestEntry,
  testContext: TestContext,
 ): Promise<void> => {
- dispatch({ name: 'test_fn_start', test });
+ dispatch({name: 'test_fn_start', test});
  const timeout = test.timeout || getState().testTimeout;
  invariant(test.fn, `Tests with no 'fn' should have 'mode' set to 'skipped'`);
 
@@ -154,9 +154,9 @@ const _callTest = async (
  return;
  }
 
- await callAsyncFn(test.fn, testContext, { isHook: false, timeout })
- .then(() => dispatch({ name: 'test_fn_success', test }))
- .catch(error => dispatch({ error, name: 'test_fn_failure', test }));
+ await callAsyncFn(test.fn, testContext, {isHook: false, timeout})
+ .then(() => dispatch({name: 'test_fn_success', test}))
+ .catch(error => dispatch({error, name: 'test_fn_failure', test}));
 };
 
 export default run;