cypress 5.6.0 → 6.2.0

package/README.md

@@ -12,7 +12,7 @@ After installing you'll be able to:
 
 ## Install
 
-Requires Node version >= 4.0.0
+Requires Node version >= 10.0.0
 
 ```sh
 npm install --save-dev cypress

package/lib/cli.js

@@ -1,5 +1,6 @@
 "use strict";
 
+// @ts-check
 const _ = require('lodash');
 
 const R = require('ramda');
@@ -156,11 +157,58 @@ function includesVersion(args) {
   return _.includes(args, 'version') || _.includes(args, '--version') || _.includes(args, '-v');
 }
 
-function showVersions() {
+function showVersions(args) {
   debug('printing Cypress version');
-  return require('./exec/versions').getVersions().then((versions = {}) => {
+  debug('additional arguments %o', args);
+  const versionParser = commander.option('--component <package|binary|electron|node>', 'component to report version for').allowUnknownOption(true);
+  const parsed = versionParser.parse(args);
+  const parsedOptions = {
+    component: parsed.component
+  };
+  debug('parsed version arguments %o', parsedOptions);
+
+  const reportAllVersions = versions => {
     logger.always('Cypress package version:', versions.package);
     logger.always('Cypress binary version:', versions.binary);
+    logger.always('Electron version:', versions.electronVersion);
+    logger.always('Bundled Node version:', versions.electronNodeVersion);
+  };
+
+  const reportComponentVersion = (componentName, versions) => {
+    const names = {
+      package: 'package',
+      binary: 'binary',
+      electron: 'electronVersion',
+      node: 'electronNodeVersion'
+    };
+
+    if (!names[componentName]) {
+      throw new Error(`Unknown component name "${componentName}"`);
+    }
+
+    const name = names[componentName];
+
+    if (!versions[name]) {
+      throw new Error(`Cannot find version for component "${componentName}" under property "${name}"`);
+    }
+
+    const version = versions[name];
+    logger.always(version);
+  };
+
+  const defaultVersions = {
+    package: undefined,
+    binary: undefined,
+    electronVersion: undefined,
+    electronNodeVersion: undefined
+  };
+  return require('./exec/versions').getVersions().then((versions = defaultVersions) => {
+    if (parsedOptions.component) {
+      reportComponentVersion(parsedOptions.component, versions);
+    } else {
+      reportAllVersions(versions);
+    }
+
     process.exit(0);
   }).catch(util.logErrorExit1);
 }
@@ -266,7 +314,9 @@ module.exports = {
     program.command('help').description('Shows CLI help and exits').action(() => {
       program.help();
     });
-    program.option('-v, --version', text('version')).command('version').description(text('version')).action(showVersions);
+    program.option('-v, --version', text('version')).command('version').description(text('version')).action(() => {
+      showVersions(args);
+    });
     addCypressRunCommand(program).action((...fnArgs) => {
       debug('running Cypress with args %o', fnArgs);
 
@@ -346,14 +396,14 @@ module.exports = {
       // and now does not understand top level options
       // .option('-v, --version').command('version')
       // so we have to manually catch '-v, --version'
-      return showVersions();
+      return showVersions(args);
     }
 
     debug('program parsing arguments');
     return program.parse(args);
   }
 
-};
+}; // @ts-ignore
 
 if (!module.parent) {
   logger.error('This CLI module should be required from another Node module');

package/lib/errors.js

@@ -225,24 +225,6 @@ const childProcessKilled = (eventName, signal) => {
   };
 };
 
-const removed = {
-  CYPRESS_BINARY_VERSION: {
-    description: stripIndent`
-    The environment variable CYPRESS_BINARY_VERSION has been renamed to CYPRESS_INSTALL_BINARY as of version ${chalk.green('3.0.0')}
-    `,
-    solution: stripIndent`
-    You should set CYPRESS_INSTALL_BINARY instead.
-    `
-  },
-  CYPRESS_SKIP_BINARY_INSTALL: {
-    description: stripIndent`
-    The environment variable CYPRESS_SKIP_BINARY_INSTALL has been removed as of version ${chalk.green('3.0.0')}
-    `,
-    solution: stripIndent`
-      To skip the binary install, set CYPRESS_INSTALL_BINARY=0
-    `
-  }
-};
 const CYPRESS_RUN_BINARY = {
   notValid: value => {
     const properFormat = `**/${state.getPlatformExecutable()}`;
@@ -404,7 +386,6 @@ module.exports = {
     failedUnzip,
     invalidCypressEnv,
     invalidCacheDirectory,
-    removed,
     CYPRESS_RUN_BINARY,
     smokeTestFailure,
     childProcessKilled,

package/lib/exec/run.js

@@ -78,13 +78,6 @@ const processRunOptions = (options = {}) => {
     args.push('--browser', options.browser);
   }
 
-  if (options.ci) {
-    // push to display the deprecation message
-    args.push('--ci'); // also automatically record
-
-    args.push('--record', true);
-  }
-
   if (options.ciBuildId) {
     args.push('--ci-build-id', options.ciBuildId);
   }
@@ -124,7 +117,7 @@ const processRunOptions = (options = {}) => {
 
   if (options.key == null) {
     debug('--key is not set, looking up environment variable CYPRESS_RECORD_KEY');
-    options.key = util.getEnv('CYPRESS_RECORD_KEY') || util.getEnv('CYPRESS_CI_KEY');
+    options.key = util.getEnv('CYPRESS_RECORD_KEY');
   } // if we have a key assume we're in record mode
 
 
@@ -150,7 +143,7 @@ const processRunOptions = (options = {}) => {
   // already in ci mode, then send it up
 
 
-  if (options.record != null && !options.ci) {
+  if (options.record != null) {
     args.push('--record', options.record);
   } // if we have a specific reporter push that into the args
 

package/lib/exec/versions.js

@@ -34,11 +34,23 @@ const getVersions = () => {
     }
 
     return state.getBinaryDir();
-  }).then(state.getBinaryPkgVersionAsync).then(binaryVersion => {
-    return {
+  }).then(state.getBinaryPkgAsync).then(pkg => {
+    const versions = {
+      binary: state.getBinaryPkgVersion(pkg),
+      electronVersion: state.getBinaryElectronVersion(pkg),
+      electronNodeVersion: state.getBinaryElectronNodeVersion(pkg)
+    };
+    debug('binary versions %o', versions);
+    return versions;
+  }).then(binaryVersions => {
+    const versions = {
       package: util.pkgVersion(),
-      binary: binaryVersion || 'not installed'
+      binary: binaryVersions.binary || 'not installed',
+      electronVersion: binaryVersions.electronVersion || 'not found',
+      electronNodeVersion: binaryVersions.electronNodeVersion || 'not found'
     };
+    debug('combined versions %o', versions);
+    return versions;
   });
 };
 

package/lib/tasks/install.js

@@ -219,15 +219,6 @@ const downloadAndUnzip = ({
 };
 
 const start = (options = {}) => {
-  // handle deprecated / removed
-  if (util.getEnv('CYPRESS_BINARY_VERSION')) {
-    return throwFormErrorText(errors.removed.CYPRESS_BINARY_VERSION)();
-  }
-
-  if (util.getEnv('CYPRESS_SKIP_BINARY_INSTALL')) {
-    return throwFormErrorText(errors.removed.CYPRESS_SKIP_BINARY_INSTALL)();
-  }
-
   debug('installing with options %j', options);
 
   _.defaults(options, {
@@ -279,7 +270,7 @@ const start = (options = {}) => {
     ${err.message}
     `);
   }).then(() => {
-    return Promise.all([state.getBinaryPkgVersionAsync(binaryDir), getVersionSpecifier()]);
+    return Promise.all([state.getBinaryPkgAsync(binaryDir).then(state.getBinaryPkgVersion), getVersionSpecifier()]);
   }).then(([binaryVersion, versionSpecifier]) => {
     if (!binaryUrlOverride && versionSpecifier) {
       const computedBinaryUrl = getBinaryUrlFromPrereleaseNpmUrl(versionSpecifier);

package/lib/tasks/state.js

@@ -8,6 +8,8 @@ const path = require('path');
 
 const untildify = require('untildify');
 
+const R = require('ramda');
+
 const debug = require('debug')('cypress:cli');
 
 const fs = require('../fs');
@@ -183,8 +185,13 @@ const writeBinaryVerifiedAsync = (verified, binaryDir) => {
 const getPathToExecutable = binaryDir => {
   return path.join(binaryDir, getPlatformExecutable());
 };
+/**
+ * Resolves with an object read from the binary app package.json file.
+ * If the file does not exist resolves with null
+ */
+
 
-const getBinaryPkgVersionAsync = binaryDir => {
+const getBinaryPkgAsync = binaryDir => {
   const pathToPackageJson = getBinaryPkgPath(binaryDir);
   debug('Reading binary package.json from:', pathToPackageJson);
   return fs.pathExistsAsync(pathToPackageJson).then(exists => {
@@ -192,15 +199,22 @@ const getBinaryPkgVersionAsync = binaryDir => {
       return null;
     }
 
-    return fs.readJsonAsync(pathToPackageJson).get('version');
+    return fs.readJsonAsync(pathToPackageJson);
   });
 };
 
+const getBinaryPkgVersion = R.propOr(null, 'version');
+const getBinaryElectronVersion = R.propOr(null, 'electronVersion');
+const getBinaryElectronNodeVersion = R.propOr(null, 'electronNodeVersion');
 module.exports = {
   getPathToExecutable,
   getPlatformExecutable,
-  getBinaryPkgVersionAsync,
+  // those names start to sound like Java
+  getBinaryElectronNodeVersion,
+  getBinaryElectronVersion,
+  getBinaryPkgVersion,
   getBinaryVerifiedAsync,
+  getBinaryPkgAsync,
   getBinaryPkgPath,
   getBinaryDir,
   getCacheDir,

package/lib/tasks/verify.js

@@ -284,7 +284,9 @@ const start = (options = {}) => {
   }).tap(() => {
     return debug('binaryDir is ', binaryDir);
   }).then(() => {
-    return state.getBinaryPkgVersionAsync(binaryDir);
+    return state.getBinaryPkgAsync(binaryDir);
+  }).then(pkg => {
+    return state.getBinaryPkgVersion(pkg);
   }).then(binaryVersion => {
     if (!binaryVersion) {
       debug('no Cypress binary found for cli version ', packageVersion);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cypress",
-  "version": "5.6.0",
+  "version": "6.2.0",
   "main": "index.js",
   "scripts": {
     "postinstall": "node index.js --exec install",

package/types/cypress-eventemitter.d.ts

@@ -6,3 +6,24 @@ interface EventEmitter extends EventEmitter2 {
   emitMap: (eventName: string, args: any[]) => Array<(...args: any[]) => any>
   emitThen: (eventName: string, args: any[]) => Bluebird.BluebirdStatic
 }
+
+// Copied from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/node/events.d.ts
+// to avoid type conflict.
+interface NodeEventEmitter {
+  addListener(event: string | symbol, listener: (...args: any[]) => void): this
+  on(event: string | symbol, listener: (...args: any[]) => void): this
+  once(event: string | symbol, listener: (...args: any[]) => void): this
+  removeListener(event: string | symbol, listener: (...args: any[]) => void): this
+  off(event: string | symbol, listener: (...args: any[]) => void): this
+  removeAllListeners(event?: string | symbol): this
+  setMaxListeners(n: number): this
+  getMaxListeners(): number
+  listeners(event: string | symbol): Array<(...args: any[]) => void>
+  rawListeners(event: string | symbol): Array<(...args: any[]) => void>
+  emit(event: string | symbol, ...args: any[]): boolean
+  listenerCount(type: string | symbol): number
+  // Added in Node 6...
+  prependListener(event: string | symbol, listener: (...args: any[]) => void): this
+  prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this
+  eventNames(): Array<string | symbol>
+}

package/types/cypress.d.ts

@@ -1,3 +1,5 @@
+/// <reference path="./cypress-npm-api.d.ts" />
+
 declare namespace Cypress {
   type FileContents = string | any[] | object
   type HistoryDirection = 'back' | 'forward'
@@ -116,6 +118,17 @@ declare namespace Cypress {
    */
   type CypressSpecType = 'integration' | 'component'
 
+  /**
+   * A Cypress spec.
+   */
+  interface Spec {
+    name: string // "config_passing_spec.js"
+    relative: string // "cypress/integration/config_passing_spec.js" or "__all" if clicked all specs button
+    absolute: string // "/Users/janelane/app/cypress/integration/config_passing_spec.js"
+    specFilter?: string // optional spec filter used by the user
+    specType?: CypressSpecType
+  }
+
   /**
    * Window type for Application Under Test(AUT)
    */
@@ -164,6 +177,9 @@ declare namespace Cypress {
      */
     minimatch: typeof Minimatch.minimatch
     /**
+     * @deprecated Will be removed in a future version.
+     * Consider including your own datetime formatter in your tests.
+     *
      * Cypress automatically includes moment.js and exposes it as Cypress.moment.
      *
      * @see https://on.cypress.io/moment
@@ -224,23 +240,17 @@ declare namespace Cypress {
     /**
      * Currently executing spec file.
      * @example
-    ```
-    Cypress.spec
-    // {
-    //  name: "config_passing_spec.coffee",
-    //  relative: "cypress/integration/config_passing_spec.coffee",
-    //  absolute: "/users/smith/projects/web/cypress/integration/config_passing_spec.coffee"
-    //  specType: "integration"
-    // }
-    ```
+     * ```
+     * Cypress.spec
+     * // {
+     * //  name: "config_passing_spec.coffee",
+     * //  relative: "cypress/integration/config_passing_spec.coffee",
+     * //  absolute: "/users/smith/projects/web/cypress/integration/config_passing_spec.coffee"
+     * //  specType: "integration"
+     * // }
+     * ```
      */
-    spec: {
-      name: string // "config_passing_spec.coffee"
-      relative: string // "cypress/integration/config_passing_spec.coffee" or "__all" if clicked all specs button
-      absolute: string
-      specFilter?: string // optional spec filter used by the user
-      specType?: CypressSpecType
-    }
+    spec: Spec
 
     /**
      * Information about the browser currently running the tests
@@ -421,7 +431,7 @@ declare namespace Cypress {
       /**
        * Returns a boolean indicating whether an element is hidden.
        */
-      isHidden(element: JQuery | HTMLElement): boolean
+      isHidden(element: JQuery | HTMLElement, methodName?: string, options?: object): boolean
       /**
        * Returns a boolean indicating whether an element can receive focus.
        */
@@ -474,7 +484,7 @@ declare namespace Cypress {
       getContainsSelector(text: string, filter?: string): JQuery.Selector
       getFirstDeepestElement(elements: HTMLElement[], index?: number): HTMLElement
       getWindowByElement(element: JQuery | HTMLElement): JQuery | HTMLElement
-      getReasonIsHidden(element: JQuery | HTMLElement): string
+      getReasonIsHidden(element: JQuery | HTMLElement, options?: object): string
       getFirstScrollableParent(element: JQuery | HTMLElement): JQuery | HTMLElement
       getFirstFixedOrStickyPositionParent(element: JQuery | HTMLElement): JQuery | HTMLElement
       getFirstStickyPositionParent(element: JQuery | HTMLElement): JQuery | HTMLElement
@@ -1477,8 +1487,9 @@ declare namespace Cypress {
     root<E extends Node = HTMLHtmlElement>(options?: Partial<Loggable>): Chainable<JQuery<E>> // can't do better typing unless we ignore the `.within()` case
 
     /**
-     * Use `cy.route()` to manage the behavior of network requests.
+     * @deprecated Use `cy.intercept()` instead.
      *
+     * Use `cy.route()` to manage the behavior of network requests.
      * @see https://on.cypress.io/route
      * @example
      *    cy.server()
@@ -1486,6 +1497,8 @@ declare namespace Cypress {
      */
     route(url: string | RegExp, response?: string | object): Chainable<null>
     /**
+     * @deprecated Use `cy.intercept()` instead.
+     *
      * Spy or stub request with specific method and url.
      *
      * @see https://on.cypress.io/route
@@ -1496,6 +1509,8 @@ declare namespace Cypress {
      */
     route(method: string, url: string | RegExp, response?: string | object): Chainable<null>
     /**
+     * @deprecated Use `cy.intercept()` instead.
+     *
      * Set a route by returning an object literal from a callback function.
      * Functions that return a Promise will automatically be awaited.
      *
@@ -1514,6 +1529,8 @@ declare namespace Cypress {
      */
     route(fn: () => RouteOptions): Chainable<null>
     /**
+     * @deprecated Use `cy.intercept()` instead.
+     *
      * Spy or stub a given route.
      *
      * @see https://on.cypress.io/route
@@ -1581,6 +1598,8 @@ declare namespace Cypress {
     select(value: string | string[], options?: Partial<SelectOptions>): Chainable<Subject>
 
     /**
+     * @deprecated Use `cy.intercept()` instead.
+     *
      * Start a server to begin routing responses to `cy.route()` and `cy.request()`.
      *
      * @example
@@ -2013,50 +2032,6 @@ declare namespace Cypress {
      *    cy.wait(1000) // wait for 1 second
      */
     wait(ms: number, options?: Partial<Loggable & Timeoutable>): Chainable<Subject>
-    /**
-     * Wait for a specific XHR to respond.
-     *
-     * @see https://on.cypress.io/wait
-     * @param {string} alias - Name of the alias to wait for.
-     *
-    ```
-    // Wait for the route aliased as 'getAccount' to respond
-    // without changing or stubbing its response
-    cy.server()
-    cy.route('/accounts/*').as('getAccount')
-    cy.visit('/accounts/123')
-    cy.wait('@getAccount').then((xhr) => {
-      // we can now access the low level xhr
-      // that contains the request body,
-      // response body, status, etc
-    })
-    ```
-     */
-    wait(alias: string, options?: Partial<Loggable & Timeoutable & TimeoutableXHR>): Chainable<WaitXHR>
-    /**
-     * Wait for list of XHR requests to complete.
-     *
-     * @see https://on.cypress.io/wait
-     * @param {string[]} aliases - An array of aliased routes as defined using the `.as()` command.
-     *
-    ```
-    // wait for 3 XHR requests to complete
-    cy.server()
-    cy.route('users/*').as('getUsers')
-    cy.route('activities/*').as('getActivities')
-    cy.route('comments/*').as('getComments')
-    cy.visit('/dashboard')
-
-    cy.wait(['@getUsers', '@getActivities', '@getComments'])
-      .then((xhrs) => {
-        // xhrs will now be an array of matching XHR's
-        // xhrs[0] <-- getUsers
-        // xhrs[1] <-- getActivities
-        // xhrs[2] <-- getComments
-      })
-    ```
-     */
-    wait(alias: string[], options?: Partial<Loggable & Timeoutable & TimeoutableXHR>): Chainable<WaitXHR[]>
 
     /**
      * Get the window object of the page that is currently active.
@@ -2322,20 +2297,46 @@ declare namespace Cypress {
     force: boolean
   }
 
+  type scrollBehaviorOptions = false | 'center' | 'top' | 'bottom' | 'nearest'
+
+  /**
+   * Options to affect Actionability checks
+   * @see https://docs.cypress.io/guides/core-concepts/interacting-with-elements.html#Actionability
+   */
+  interface ActionableOptions extends Forceable {
+    /**
+     * Whether to wait for elements to finish animating before executing commands
+     *
+     * @default true
+     */
+    waitForAnimations: boolean
+    /**
+     * The distance in pixels an element must exceed over time to be considered animating
+     * @default 5
+     */
+    animationDistanceThreshold: number
+    /**
+     * Viewport position to which an element should be scrolled prior to action commands. Setting `false` disables scrolling.
+     *
+     * @default 'top'
+     */
+    scrollBehavior: scrollBehaviorOptions
+  }
+
   interface BlurOptions extends Loggable, Forceable { }
 
-  interface CheckOptions extends Loggable, Timeoutable, Forceable {
+  interface CheckOptions extends Loggable, Timeoutable, ActionableOptions {
     interval: number
   }
 
-  interface ClearOptions extends Loggable, Timeoutable, Forceable {
+  interface ClearOptions extends Loggable, Timeoutable, ActionableOptions {
     interval: number
   }
 
   /**
    * Object to change the default behavior of .click().
    */
-  interface ClickOptions extends Loggable, Timeoutable, Forceable {
+  interface ClickOptions extends Loggable, Timeoutable, ActionableOptions {
     /**
      * Serially click multiple elements
      *
@@ -2563,6 +2564,11 @@ declare namespace Cypress {
      * @default true
      */
     waitForAnimations: boolean
+    /**
+     * Viewport position to which an element should be scrolled prior to action commands. Setting `false` disables scrolling.
+     * @default 'top'
+     */
+    scrollBehavior: scrollBehaviorOptions
     /**
      * Firefox version 79 and below only: The number of tests that will run between forced garbage collections.
      * If a number is supplied, it will apply to `run` mode and `open` mode.
@@ -2571,16 +2577,16 @@ declare namespace Cypress {
      */
     firefoxGcInterval: Nullable<number | { runMode: Nullable<number>, openMode: Nullable<number> }>
     /**
-     * Enables AST-based JS/HTML rewriting. This may fix issues caused by the existing regex-based JS/HTML replacement
-     * algorithm.
+     * Allows listening to the `before:run`, `after:run`, `before:spec`, and `after:spec` events in the plugins file.
      * @default false
      */
-    experimentalSourceRewriting: boolean
+    experimentalRunEvents: boolean
     /**
-     * Enables `cy.route2`, which can be used to dynamically intercept/stub/await any HTTP request or response (XHRs, fetch, beacons, etc.)
+     * Enables AST-based JS/HTML rewriting. This may fix issues caused by the existing regex-based JS/HTML replacement
+     * algorithm.
      * @default false
      */
-    experimentalNetworkStubbing: boolean
+    experimentalSourceRewriting: boolean
     /**
      * Number of times to retry a failed test.
      * If a number is set, tests will retry in both runMode and openMode.
@@ -2598,7 +2604,7 @@ declare namespace Cypress {
     includeShadowDom: boolean
   }
 
-  interface TestConfigOverrides extends Partial<Pick<ConfigOptions, 'baseUrl' | 'defaultCommandTimeout' | 'taskTimeout' | 'animationDistanceThreshold' | 'waitForAnimations' | 'viewportHeight' | 'viewportWidth' | 'requestTimeout' | 'execTimeout' | 'env' | 'responseTimeout' | 'retries' | 'includeShadowDom'>> {
+  interface TestConfigOverrides extends Partial<Pick<ConfigOptions, 'animationDistanceThreshold' | 'baseUrl' | 'defaultCommandTimeout' | 'env' | 'execTimeout' | 'includeShadowDom' | 'requestTimeout' | 'responseTimeout' | 'retries' | 'scrollBehavior' | 'taskTimeout' | 'viewportHeight' | 'viewportWidth' | 'waitForAnimations'>> {
     browser?: IsBrowserMatcher | IsBrowserMatcher[]
   }
 
@@ -2794,7 +2800,7 @@ declare namespace Cypress {
    *
    * @see https://on.cypress.io/type
    */
-  interface TypeOptions extends Loggable, Timeoutable {
+  interface TypeOptions extends Loggable, Timeoutable, ActionableOptions {
     /**
      * Delay after each keypress (ms)
      *
@@ -2808,12 +2814,6 @@ declare namespace Cypress {
      * @default true
      */
     parseSpecialCharSequences: boolean
-    /**
-     * Forces the action, disables waiting for actionability
-     *
-     * @default false
-     */
-    force: boolean
     /**
      * Keep a modifier activated between commands
      *
@@ -2906,7 +2906,7 @@ declare namespace Cypress {
   /**
    * Options to change the default behavior of .trigger()
    */
-  interface TriggerOptions extends Loggable, Timeoutable, Forceable {
+  interface TriggerOptions extends Loggable, Timeoutable, ActionableOptions {
     /**
      * Whether the event bubbles
      *
@@ -4982,7 +4982,7 @@ declare namespace Cypress {
     dimensions?: Dimensions
   }
 
-  interface FileObject {
+  interface FileObject extends NodeEventEmitter {
     filePath: string
     outputPath: string
     shouldWatch: boolean
@@ -4999,9 +4999,31 @@ declare namespace Cypress {
     [key: string]: Task
   }
 
+  interface SystemDetails {
+    osName: string
+    osVersion: string
+  }
+
+  interface BeforeRunDetails {
+    browser: Browser
+    config: ConfigOptions
+    cypressVersion: string
+    group?: string
+    parallel: boolean
+    runUrl?: string
+    specs: Spec[]
+    specPattern: string[]
+    system: SystemDetails
+    tag?: string
+  }
+
   interface PluginEvents {
-    (action: 'before:browser:launch', fn: (browser: Browser, browserLaunchOptions: BrowserLaunchOptions) => void | BrowserLaunchOptions | Promise<BrowserLaunchOptions>): void
+    (action: 'after:run', fn: (results: CypressCommandLine.CypressRunResult | CypressCommandLine.CypressFailedRunResult) => void | Promise<void>): void
     (action: 'after:screenshot', fn: (details: ScreenshotDetails) => void | AfterScreenshotReturnObject | Promise<AfterScreenshotReturnObject>): void
+    (action: 'after:spec', fn: (spec: Spec, results: CypressCommandLine.RunResult) => void | Promise<void>): void
+    (action: 'before:run', fn: (runDetails: BeforeRunDetails) => void | Promise<void>): void
+    (action: 'before:spec', fn: (spec: Spec) => void | Promise<void>): void
+    (action: 'before:browser:launch', fn: (browser: Browser, browserLaunchOptions: BrowserLaunchOptions) => void | BrowserLaunchOptions | Promise<BrowserLaunchOptions>): void
     (action: 'file:preprocessor', fn: (file: FileObject) => string | Promise<string>): void
     (action: 'task', tasks: Tasks): void
   }
@@ -5255,7 +5277,8 @@ declare namespace Cypress {
     duration: number
     headers: { [key: string]: string }
     isOkStatusCode: boolean
-    redirectedToUrl: string
+    redirects?: string[]
+    redirectedToUrl?: string
     requestHeaders: { [key: string]: string }
     status: number
     statusText: string

package/types/net-stubbing.ts

@@ -70,7 +70,7 @@ type Method =
     | 'unsubscribe'
 
 export namespace CyHttpMessages {
-  interface BaseMessage {
+  export interface BaseMessage {
     body?: any
     headers: { [key: string]: string }
     url: string
@@ -178,8 +178,9 @@ export type NumberMatcher = number | number[]
 /**
  * Request/response cycle.
  */
-export interface Request {
+export interface Interception {
   id: string
+  routeHandlerId: string
   /* @internal */
   log: any
   request: CyHttpMessages.IncomingRequest
@@ -191,16 +192,20 @@ export interface Request {
   response?: CyHttpMessages.IncomingResponse
   /* @internal */
   responseHandler?: HttpResponseInterceptor
+  /**
+   * The error that occurred during this request.
+   */
+  error?: Error
   /**
    * Was `cy.wait()` used to wait on the response to this request?
    * @internal
    */
   responseWaited: boolean
   /* @internal */
-  state: RequestState
+  state: InterceptionState
 }
 
-export type RequestState =
+export type InterceptionState =
   'Received' |
   'Intercepted' |
   'ResponseReceived' |
@@ -214,7 +219,8 @@ export interface Route {
   options: RouteMatcherOptions
   handler: RouteHandler
   hitCount: number
-  requests: { [key: string]: Request }
+  requests: { [key: string]: Interception }
+  command: any
 }
 
 export interface RouteMap { [key: string]: Route }
@@ -224,13 +230,9 @@ export interface RouteMap { [key: string]: Route }
  */
 export type RouteMatcher = StringMatcher | RouteMatcherOptions
 
-export interface RouteMatcherCompatOptions {
-  response?: string | object
-}
-
 export type RouteMatcherOptions = RouteMatcherOptionsGeneric<StringMatcher>
 
-export interface RouteMatcherOptionsGeneric<S> extends RouteMatcherCompatOptions {
+export interface RouteMatcherOptionsGeneric<S> {
   /**
    * Match against the username and password used in HTTP Basic authentication.
    */
@@ -248,6 +250,11 @@ export interface RouteMatcherOptionsGeneric<S> extends RouteMatcherCompatOptions
    * If 'false', only HTTP requests will be matched.
    */
   https?: boolean
+  /**
+   * If `true`, will match the supplied `url` against incoming `path`s.
+   * Requires a `url` argument. Cannot be used with a `path` argument.
+   */
+  matchUrlAgainstPath?: boolean
   /**
    * Match against the request's HTTP method.
    * @default '*'
@@ -328,41 +335,112 @@ export interface GenericStaticResponse<Fixture, Body> {
  */
 export type StringMatcher = GlobPattern | RegExp
 
+interface WaitOptions {
+  /**
+   * Displays the command in the Command Log
+   *
+   * @default true
+   */
+  log: boolean
+  /**
+   * Time to wait for the request (ms)
+   *
+   * @default {@link Timeoutable#timeout}
+   * @see https://on.cypress.io/configuration#Timeouts
+   */
+  requestTimeout: number
+  /**
+   * Time to wait for the response (ms)
+   *
+   * @default {@link Timeoutable#timeout}
+   * @see https://on.cypress.io/configuration#Timeouts
+   */
+  responseTimeout: number
+  /**
+   * Time to wait (ms)
+   *
+   * @default defaultCommandTimeout
+   * @see https://on.cypress.io/configuration#Timeouts
+   */
+  timeout: number
+}
+
 declare global {
   namespace Cypress {
     interface Chainable<Subject = any> {
       /**
-       * Use `cy.route2()` to stub and intercept HTTP requests and responses.
+       * Use `cy.intercept()` to stub and intercept HTTP requests and responses.
        *
-       * Note: this command is only available if you have set the `experimentalNetworkStubbing`
-       * configuration option to `true`.
-       *
-       * @see https://on.cypress.io/route2
+       * @see https://on.cypress.io/intercept
        * @example
-       *    cy.route2('https://localhost:7777/users', [{id: 1, name: 'Pat'}])
+       *    cy.intercept('https://localhost:7777/users', [{id: 1, name: 'Pat'}])
        * @example
-       *    cy.route2('https://localhost:7777/protected-endpoint', (req) => {
+       *    cy.intercept('https://localhost:7777/protected-endpoint', (req) => {
        *      req.headers['authorization'] = 'basic fooabc123'
        *    })
        * @example
-       *    cy.route2('https://localhost:7777/some-response', (req) => {
+       *    cy.intercept('https://localhost:7777/some-response', (req) => {
        *      req.reply(res => {
        *        res.body = 'some new body'
        *      })
        *    })
        */
-      route2(url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      intercept(url: RouteMatcher, response?: RouteHandler): Chainable<null>
       /**
-       * Use `cy.route2()` to stub and intercept HTTP requests and responses.
+       * Use `cy.intercept()` to stub and intercept HTTP requests and responses.
        *
-       * Note: this command is only available if you have set the `experimentalNetworkStubbing`
-       * configuration option to `true`.
-       *
-       * @see https://on.cypress.io/route2
+       * @see https://on.cypress.io/intercept
        * @example
-       *    cy.route2('GET', 'http://foo.com/fruits', ['apple', 'banana', 'cherry'])
+       *    cy.intercept('GET', 'http://foo.com/fruits', ['apple', 'banana', 'cherry'])
+       */
+      intercept(method: Method, url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      /**
+       * @deprecated Use `cy.intercept()` instead.
+       */
+      route2(url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      /**
+       * @deprecated Use `cy.intercept()` instead.
        */
       route2(method: Method, url: RouteMatcher, response?: RouteHandler): Chainable<null>
+      /**
+       * Wait for a specific request to complete.
+       *
+       * @see https://on.cypress.io/wait
+       * @param {string} alias - Name of the alias to wait for.
+       *
+      ```
+      // Wait for the route aliased as 'getAccount' to respond
+      // without changing or stubbing its response
+      cy.intercept('https://api.example.com/accounts/*').as('getAccount')
+      cy.visit('/accounts/123')
+      cy.wait('@getAccount').then((interception) => {
+        // we can now access the low level request
+        // that contains the request body,
+        // response body, status, etc
+      })
+      ```
+      */
+      wait(alias: string, options?: Partial<WaitOptions>): Chainable<Interception>
+      /**
+       * Wait for list of requests to complete.
+       *
+       * @see https://on.cypress.io/wait
+       * @param {string[]} aliases - An array of aliased routes as defined using the `.as()` command.
+       *
+      ```
+      // wait for 3 XHR requests to complete
+      cy.intercept('users/*').as('getUsers')
+      cy.intercept('activities/*').as('getActivities')
+      cy.intercept('comments/*').as('getComments')
+      cy.visit('/dashboard')
+
+      cy.wait(['@getUsers', '@getActivities', '@getComments'])
+        .then((interceptions) => {
+          // intercepts will now be an array of matching HTTP requests
+        })
+      ```
+      */
+      wait(alias: string[], options?: Partial<WaitOptions>): Chainable<Interception[]>
     }
   }
 }