diff --git a/packages/driver/src/cypress/error_messages.js b/packages/driver/src/cypress/error_messages.js
index 1526047fd308..40c481b19ad7 100644
--- a/packages/driver/src/cypress/error_messages.js
+++ b/packages/driver/src/cypress/error_messages.js
@@ -1,1775 +1,1795 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const _ = require("lodash");
-const capitalize = require('underscore.string/capitalize');
-
-const divider = (num, char) => Array(num).join(char);
-
-const format = function(data) {
-  switch (false) {
-    case !_.isString(data):
-      return _.truncate(data, { length: 2000 });
-    case !_.isObject(data):
-      return JSON.stringify(data, null, 2);
-    default:
-      return data;
+const _ = require('lodash')
+const { stripIndent } = require('common-tags')
+const capitalize = require('underscore.string/capitalize')
+
+const divider = (num, char) => {
+  return Array(num).join(char)
+}
+
+const format = (data) => {
+  if (_.isString(data)) {
+    return _.truncate(data, { length: 2000 })
   }
-};
 
-const formatConfigFile = function(configFile) {
-  if (configFile === false) {
-    return "`cypress.json` (currently disabled by --config-file=false)";
+  if (_.isObject(data)) {
+    return JSON.stringify(data, null, 2)
   }
 
-  return `\`${format(configFile)}\``;
-};
+  return data
+}
 
-const formatRedirect = redirect => `  - ${redirect}`;
+const formatConfigFile = (configFile) => {
+  if (configFile === false) {
+    return '`cypress.json` (currently disabled by --config-file=false)'
+  }
 
-const formatRedirects = (redirects = []) => _.map(redirects, formatRedirect);
+  return `\`${format(configFile)}\``
+}
 
-const formatProp = function(memo, field) {
-  const {key, value} = field;
+const formatRedirects = (redirects = [], listIndentSize) => {
+  return _.map(redirects, (redirect) => {
+    return `${' '.repeat(listIndentSize)}  - ${redirect}`
+  })
+}
+
+const formatProp = (memo, field) => {
+  const { key, value } = field
 
   if (value != null) {
-    memo.push(capitalize(key) + ": " + format(value));
+    memo.push(`${capitalize(key)}: ${format(value)}`)
   }
-  return memo;
-};
 
-const cmd = function(command, args = "") {
-  const prefix = command.startsWith("Cypress") ? "" : "cy.";
+  return memo
+}
+
+const cmd = (command, args = '') => {
+  const prefix = command.startsWith('Cypress') ? '' : 'cy.'
 
-  return `\`${prefix}${command}(${args})\``;
-};
+  return `\`${prefix}${command}(${args})\``
+}
 
-const getScreenshotDocsPath = function(cmd) {
-  if (cmd === "Cypress.Screenshot.defaults") { return "screenshot-api"; } else { return "screenshot"; }
-};
+const getScreenshotDocsPath = (cmd) => {
+  if (cmd === 'Cypress.Screenshot.defaults') {
+    return 'screenshot-api'
+  }
 
-const getRedirects = function(obj, phrase) {
-  const redirects = obj.redirects != null ? obj.redirects : [];
+  return 'screenshot'
+}
 
-  if (!redirects.length) { return ""; }
+const getRedirects = (obj, phrase, listIndentSize) => {
+  const redirects = obj.redirects ?? []
 
-  const word = redirects.length > 1 ? "times" : "time";
+  if (!redirects.length) {
+    return ''
+  }
 
-  const list = formatRedirects(redirects);
+  const word = redirects.length > 1 ? 'times' : 'time'
 
-  return `\
-${phrase} '${redirects.length}' ${word} to:
+  const list = formatRedirects(redirects, listIndentSize)
 
-${list.join("\n")}\
-`;
-};
+  return [
+    `${phrase} '${redirects.length}' ${word} to:`,
+    '',
+    `${list.join('\n')}`,
+  ].join('\n')
+}
 
-const getHttpProps = (fields = []) => _
-.chain(fields)
-.reduce(formatProp, [])
-.join("\n")
-.value();
+const getHttpProps = (fields = []) => {
+  return _
+  .chain(fields)
+  .reduce(formatProp, [])
+  .join('\n')
+  .value()
+}
+
+const cyStripIndent = (str, indentSize) => {
+  const indent = ' '.repeat(indentSize)
+
+  return str.split('\n').map((s) => {
+    return s.startsWith(indent)
+      ? s.substring(indentSize)
+      : s
+  }).join('\n')
+}
 
 module.exports = {
   add: {
-    type_missing: "`Cypress.add(key, fn, type)` must include a type!"
+    type_missing: '`Cypress.add(key, fn, type)` must include a type!',
   },
 
   agents: {
-    deprecated_warning: `${cmd('agents')} is deprecated. Use ${cmd('stub')} and ${cmd('spy')} instead.`
+    deprecated_warning: `${cmd('agents')} is deprecated. Use ${cmd('stub')} and ${cmd('spy')} instead.`,
   },
 
   alias: {
-    invalid: "Invalid alias: `{{name}}`.\nYou forgot the `@`. It should be written as: `@{{displayName}}`.",
+    invalid: 'Invalid alias: `{{name}}`.\nYou forgot the `@`. It should be written as: `@{{displayName}}`.',
     not_registered_with_available: `${cmd('{{cmd}}')} could not find a registered alias for: \`@{{displayName}}\`.\nAvailable aliases are: \`{{availableAliases}}\`.`,
-    not_registered_without_available: `${cmd('{{cmd}}')} could not find a registered alias for: \`@{{displayName}}\`.\nYou have not aliased anything yet.`
+    not_registered_without_available: `${cmd('{{cmd}}')} could not find a registered alias for: \`@{{displayName}}\`.\nYou have not aliased anything yet.`,
   },
 
   as: {
     empty_string: {
       message: `${cmd('as')} cannot be passed an empty string.`,
-      docsUrl: "https://on.cypress.io/as"
+      docsUrl: 'https://on.cypress.io/as',
     },
     invalid_type: {
       message: `${cmd('as')} can only accept a string.`,
-      docsUrl: "https://on.cypress.io/as"
+      docsUrl: 'https://on.cypress.io/as',
     },
     invalid_first_token: {
-      message: "`{{alias}}` cannot be named starting with the `@` symbol. Try renaming the alias to `{{suggestedName}}`, or something else that does not start with the `@` symbol.",
-      docsUrl: "https://on.cypress.io/as"
+      message: '`{{alias}}` cannot be named starting with the `@` symbol. Try renaming the alias to `{{suggestedName}}`, or something else that does not start with the `@` symbol.',
+      docsUrl: 'https://on.cypress.io/as',
     },
     reserved_word: {
       message: `${cmd('as')} cannot be aliased as: \`{{alias}}\`. This word is reserved.`,
-      docsUrl: "https://on.cypress.io/as"
-    }
+      docsUrl: 'https://on.cypress.io/as',
+    },
   },
 
   blur: {
     multiple_elements: {
       message: `${cmd('blur')} can only be called on a single element. Your subject contained {{num}} elements.`,
-      docsUrl: "https://on.cypress.io/blur"
+      docsUrl: 'https://on.cypress.io/blur',
     },
     no_focused_element: {
       message: `${cmd('blur')} can only be called when there is a currently focused element.`,
-      docsUrl: "https://on.cypress.io/blur"
+      docsUrl: 'https://on.cypress.io/blur',
     },
     timed_out: {
       message: `${cmd('blur')} timed out because your browser did not receive any \`blur\` events. This is a known bug in Chrome when it is not the currently focused window.`,
-      docsUrl: "https://on.cypress.io/blur"
+      docsUrl: 'https://on.cypress.io/blur',
     },
     wrong_focused_element: {
       message: `${cmd('blur')} can only be called on the focused element. Currently the focused element is a: \`{{node}}\``,
-      docsUrl: "https://on.cypress.io/blur"
-    }
+      docsUrl: 'https://on.cypress.io/blur',
+    },
   },
 
   browser: {
-    invalid_arg: "`Cypress.{{method}}()` must be passed the name of a browser or an object to filter with. You passed: `{{obj}}`"
+    invalid_arg: '`Cypress.{{method}}()` must be passed the name of a browser or an object to filter with. You passed: `{{obj}}`',
   },
 
   chai: {
-    length_invalid_argument: "You must provide a valid number to a `length` assertion. You passed: `{{length}}`",
-    match_invalid_argument: "`match` requires its argument be a `RegExp`. You passed: `{{regExp}}`",
-    invalid_jquery_obj(obj) {
-      return `\
-You attempted to make a chai-jQuery assertion on an object that is neither a DOM object or a jQuery object.
+    length_invalid_argument: 'You must provide a valid number to a `length` assertion. You passed: `{{length}}`',
+    match_invalid_argument: '`match` requires its argument be a `RegExp`. You passed: `{{regExp}}`',
+    invalid_jquery_obj (obj) {
+      return stripIndent`\
+        You attempted to make a chai-jQuery assertion on an object that is neither a DOM object or a jQuery object.
 
-The chai-jQuery assertion you used was:
+        The chai-jQuery assertion you used was:
 
-  > ${obj.assertion}
+          > ${obj.assertion}
 
-The invalid subject you asserted on was:
+        The invalid subject you asserted on was:
 
-  > ${obj.subject}
+          > ${obj.subject}
 
-To use chai-jQuery assertions your subject must be valid.
+        To use chai-jQuery assertions your subject must be valid.
 
-This can sometimes happen if a previous assertion changed the subject.\
-`;
-    }
+        This can sometimes happen if a previous assertion changed the subject.`
+    },
   },
 
   check_uncheck: {
     invalid_element: {
       message: `${cmd('{{cmd}}')} can only be called on \`:checkbox\`{{phrase}}. Your subject {{word}} a: \`{{node}}\``,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
-    }
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
+    },
   },
 
   clear: {
     invalid_element: {
-      message: `\
-${cmd('clear')} failed because it requires a valid clearable element.
-
-The element cleared was:
-
-  > \`{{node}}\`
-
-A clearable element matches one of the following selectors:
-  'a[href]'
-  'area[href]'
-  'input'
-  'select'
-  'textarea'
-  'button'
-  'iframe'
-  '[tabindex]'
-  '[contenteditable]'\
-`,
-      docsUrl: "https://on.cypress.io/clear"
-    }
+      message: stripIndent`\
+        ${cmd('clear')} failed because it requires a valid clearable element.
+
+        The element cleared was:
+
+          > \`{{node}}\`
+
+        A clearable element matches one of the following selectors:
+          'a[href]'
+          'area[href]'
+          'input'
+          'select'
+          'textarea'
+          'button'
+          'iframe'
+          '[tabindex]'
+          '[contenteditable]'`,
+      docsUrl: 'https://on.cypress.io/clear',
+    },
   },
 
   clearCookie: {
     invalid_argument: {
       message: `${cmd('clearCookie')} must be passed a string argument for name.`,
-      docsUrl: "https://on.cypress.io/clearcookie"
-    }
+      docsUrl: 'https://on.cypress.io/clearcookie',
+    },
   },
 
   clearLocalStorage: {
     invalid_argument: {
       message: `${cmd('clearLocalStorage')} must be called with either a string or regular expression.`,
-      docsUrl: "https://on.cypress.io/clearlocalstorage"
-    }
+      docsUrl: 'https://on.cypress.io/clearlocalstorage',
+    },
   },
 
   click: {
     multiple_elements: {
       message: `${cmd('{{cmd}}')} can only be called on a single element. Your subject contained {{num}} elements. Pass \`{ multiple: true }\` if you want to serially click each element.`,
-      docsUrl: "https://on.cypress.io/click"
+      docsUrl: 'https://on.cypress.io/click',
     },
     on_select_element: {
       message: `${cmd('{{cmd}}')} cannot be called on a \`<select>\` element. Use ${cmd('select')} command instead to change the value.`,
-      docsUrl: "https://on.cypress.io/select"
-    }
+      docsUrl: 'https://on.cypress.io/select',
+    },
   },
 
   clock: {
     invalid_1st_arg: {
       message: `${cmd('clock')} only accepts a number or an \`options\` object for its first argument. You passed: \`{{arg}}\``,
-      docsUrl: "https://on.cypress.io/clock"
+      docsUrl: 'https://on.cypress.io/clock',
     },
     invalid_2nd_arg: {
       message: `${cmd('clock')} only accepts an array of function names or an \`options\` object for its second argument. You passed: \`{{arg}}\``,
-      docsUrl: "https://on.cypress.io/clock"
-    }
+      docsUrl: 'https://on.cypress.io/clock',
+    },
   },
 
   contains: {
     empty_string: {
       message: `${cmd('contains')} cannot be passed an empty string.`,
-      docsUrl: "https://on.cypress.io/contains"
+      docsUrl: 'https://on.cypress.io/contains',
     },
     invalid_argument: {
       message: `${cmd('contains')} can only accept a string, number or regular expression.`,
-      docsUrl: "https://on.cypress.io/contains"
+      docsUrl: 'https://on.cypress.io/contains',
     },
     length_option: {
       message: `${cmd('contains')} cannot be passed a \`length\` option because it will only ever return 1 element.`,
-      docsUrl: "https://on.cypress.io/contains"
+      docsUrl: 'https://on.cypress.io/contains',
     },
     regex_conflict: {
       message: `You passed a regular expression with the case-insensitive (_i_) flag and \`{ matchCase: true }\` to ${cmd('contains')}. Those options conflict with each other, so please choose one or the other.`,
-      docsUrl: "https://on.cypress.io/contains"
-    }
+      docsUrl: 'https://on.cypress.io/contains',
+    },
   },
 
   cookies: {
-    backend_error(obj) { return {
-      message: `\
-${cmd('{{cmd}}')} had an unexpected error {{action}} {{browserDisplayName}}.
-
-> {{error}}
-\
-`,
-      docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`
-    }; },
-
-    invalid_name(obj) { return {
-      message: `${cmd('{{cmd}}')} must be passed an RFC-6265-compliant cookie name. You passed:\n\n\`{{name}}\``,
-      docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`
-    }; },
-    timed_out(obj) { return {
-      message: `${cmd('{{cmd}}')} timed out waiting \`{{timeout}}ms\` to complete.`,
-      docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`
-    }; },
+    backend_error (obj) {
+      return {
+        message: [
+          `${cmd('{{cmd}}')} had an unexpected error {{action}} {{browserDisplayName}}.`,
+          ``,
+          `> {{error}}`,
+          ``,
+        ].join('\n'),
+        docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`,
+      }
+    },
+
+    invalid_name (obj) {
+      return {
+        message: `${cmd('{{cmd}}')} must be passed an RFC-6265-compliant cookie name. You passed:\n\n\`{{name}}\``,
+        docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`,
+      }
+    },
+    timed_out (obj) {
+      return {
+        message: `${cmd('{{cmd}}')} timed out waiting \`{{timeout}}ms\` to complete.`,
+        docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`,
+      }
+    },
     removed_method: {
-      message: `\
-The \`Cypress.Cookies.{{method}}()\` method has been removed.
-
-Setting, getting, and clearing cookies is now an asynchronous operation.
-
-Replace this call with the appropriate command such as:
-  - \`cy.getCookie()\`
-  - \`cy.getCookies()\`
-  - \`cy.setCookie()\`
-  - \`cy.clearCookie()\`
-  - \`cy.clearCookies()\`\
-`
-    }
+      message: stripIndent`\
+        The \`Cypress.Cookies.{{method}}()\` method has been removed.
+
+        Setting, getting, and clearing cookies is now an asynchronous operation.
+
+        Replace this call with the appropriate command such as:
+          - \`cy.getCookie()\`
+          - \`cy.getCookies()\`
+          - \`cy.setCookie()\`
+          - \`cy.clearCookie()\`
+          - \`cy.clearCookies()\``,
+    },
   },
 
   dom: {
     animating: {
-      message: `\
-${cmd('{{cmd}}')} could not be issued because this element is currently animating:
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} could not be issued because this element is currently animating:
 
-\`{{node}}\`
+        \`{{node}}\`
 
-You can fix this problem by:
-  - Passing \`{force: true}\` which disables all error checking
-  - Passing \`{waitForAnimations: false}\` which disables waiting on animations
-  - Passing \`{animationDistanceThreshold: 20}\` which decreases the sensitivity\
-`,
-      docsUrl: "https://on.cypress.io/element-is-animating"
+        You can fix this problem by:
+          - Passing \`{force: true}\` which disables all error checking
+          - Passing \`{waitForAnimations: false}\` which disables waiting on animations
+          - Passing \`{animationDistanceThreshold: 20}\` which decreases the sensitivity`,
+      docsUrl: 'https://on.cypress.io/element-is-animating',
     },
-    animation_coords_history_invalid: "coordsHistory must be at least 2 sets of coords",
-    animation_check_failed: "Not enough coord points provided to calculate distance.",
+    animation_coords_history_invalid: 'coordsHistory must be at least 2 sets of coords',
+    animation_check_failed: 'Not enough coord points provided to calculate distance.',
     center_hidden: {
-      message: `\
-${cmd('{{cmd}}')} failed because the center of this element is hidden from view:
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} failed because the center of this element is hidden from view:
 
-\`{{node}}\`
+        \`{{node}}\`
 
-Fix this problem, or use \`{force: true}\` to disable error checking.\
-`,
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
+        Fix this problem, or use \`{force: true}\` to disable error checking.`,
+      docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
     },
     covered: {
-      message: `\
-${cmd('{{cmd}}')} failed because this element:
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} failed because this element:
 
-\`{{element1}}\`
+        \`{{element1}}\`
 
-is being covered by another element:
+        is being covered by another element:
 
-\`{{element2}}\`
+        \`{{element2}}\`
 
-Fix this problem, or use {force: true} to disable error checking.\
-`,
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
+        Fix this problem, or use {force: true} to disable error checking.`,
+      docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
     },
-    pointer_events_none(obj) { return {
-      message: `\
-${cmd(obj.cmd)} failed because this element:
+    pointer_events_none (obj) {
+      return {
+        message: stripIndent`\
+          ${cmd(obj.cmd)} failed because this element:
 
-\`${obj.element}\`
+          \`${obj.element}\`
 
-has CSS \`pointer-events: none\`${obj.elementInherited ? `, inherited from this element:\n\n\`${obj.elementInherited}\`\n` : ""}
+          has CSS \`pointer-events: none\`${obj.elementInherited ? `, inherited from this element:\n\n\`${obj.elementInherited}\`\n` : ''}
 
-\`pointer-events: none\` prevents user mouse interaction.
+          \`pointer-events: none\` prevents user mouse interaction.
 
-Fix this problem, or use {force: true} to disable error checking.\
-`,
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
-    }; },
+          Fix this problem, or use {force: true} to disable error checking.`,
+        docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
+      }
+    },
     disabled: {
-      message: `\
-${cmd('{{cmd}}')} failed because this element is \`disabled\`:
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} failed because this element is \`disabled\`:
 
-\`{{node}}\`
+        \`{{node}}\`
 
-Fix this problem, or use \`{force: true}\` to disable error checking.\
-`,
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
+        Fix this problem, or use \`{force: true}\` to disable error checking.`,
+      docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
     },
     invalid_position_argument: {
-      message: "Invalid position argument: `{{position}}`. Position may only be {{validPositions}}.",
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
-    },
-    not_scrollable: `\
-${cmd('{{cmd}}')} failed because this element is not scrollable:\n
-\`{{node}}\`\n\
-`,
+      message: 'Invalid position argument: `{{position}}`. Position may only be {{validPositions}}.',
+      docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
+    },
+    not_scrollable: [
+      `${cmd('{{cmd}}')} failed because this element is not scrollable:`,
+      '`{{node}}\`',
+      '',
+    ].join('\n'),
     not_visible: {
-      message: `\
-${cmd('{{cmd}}')} failed because this element is not visible:
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} failed because this element is not visible:
 
-\`{{node}}\`
+        \`{{node}}\`
 
-{{reason}}
+        {{reason}}
 
-Fix this problem, or use \`{force: true}\` to disable error checking.\
-`,
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
+        Fix this problem, or use \`{force: true}\` to disable error checking.`,
+      docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
     },
     readonly: {
-      message: `\
-${cmd('{{cmd}}')} failed because this element is readonly:
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} failed because this element is readonly:
 
-\`{{node}}\`
+        \`{{node}}\`
 
-Fix this problem, or use \`{force: true}\` to disable error checking.\
-`,
-      docsUrl: "https://on.cypress.io/element-cannot-be-interacted-with"
-    }
+        Fix this problem, or use \`{force: true}\` to disable error checking.`,
+      docsUrl: 'https://on.cypress.io/element-cannot-be-interacted-with',
+    },
   },
 
   each: {
     invalid_argument: {
       message: `${cmd('each')} must be passed a callback function.`,
-      docsUrl: "https://on.cypress.io/each"
+      docsUrl: 'https://on.cypress.io/each',
     },
     non_array: {
       message: `${cmd('each')} can only operate on an array like subject. Your subject was: \`{{subject}}\``,
-      docsUrl: "https://on.cypress.io/each"
-    }
+      docsUrl: 'https://on.cypress.io/each',
+    },
   },
 
   exec: {
     failed: {
-      message: `${cmd('exec', '\'{{cmd}}\'')} failed with the following error:
+      message: stripIndent`
+        ${cmd('exec', '\'{{cmd}}\'')} failed with the following error:
 
-> "{{error}}"\
-`,
-      docsUrl: "https://on.cypress.io/exec"
+        > "{{error}}"`,
+      docsUrl: 'https://on.cypress.io/exec',
     },
     invalid_argument: {
       message: `${cmd('exec')} must be passed a non-empty string as its 1st argument. You passed: '{{cmd}}'.`,
-      docsUrl: "https://on.cypress.io/exec"
+      docsUrl: 'https://on.cypress.io/exec',
     },
     non_zero_exit: {
-      message: `\
-${cmd('exec', '\'{{cmd}}\'')} failed because the command exited with a non-zero code.
+      message: stripIndent`\
+        ${cmd('exec', '\'{{cmd}}\'')} failed because the command exited with a non-zero code.
 
-Pass \`{failOnNonZeroExit: false}\` to ignore exit code failures.
+        Pass \`{failOnNonZeroExit: false}\` to ignore exit code failures.
 
-Information about the failure:
-Code: {{code}}
-{{output}}\
-`,
-      docsUrl: "https://on.cypress.io/exec"
+        Information about the failure:
+        Code: {{code}}
+        {{output}}`,
+      docsUrl: 'https://on.cypress.io/exec',
     },
     timed_out: {
       message: `${cmd('exec', '\'{{cmd}}\'')} timed out after waiting \`{{timeout}}ms\`.`,
-      docsUrl: "https://on.cypress.io/exec"
-    }
+      docsUrl: 'https://on.cypress.io/exec',
+    },
   },
 
   files: {
-    unexpected_error(obj) { return {
-      message: `${cmd('{{cmd}}', '"{{file}}"')} failed while trying to {{action}} the file at the following path:
+    unexpected_error (obj) {
+      return {
+        message: stripIndent`
+          ${cmd('{{cmd}}', '"{{file}}"')} failed while trying to {{action}} the file at the following path:
 
-  \`{{filePath}}\`
+            \`{{filePath}}\`
 
-The following error occurred:
+          The following error occurred:
 
-  > "{{error}}"\
-`,
-      docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`
-    }; },
+            > "{{error}}"`,
+        docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`,
+      }
+    },
     existent: {
-      message: `${cmd('readFile', '"{{file}}"')} failed because the file exists when expected not to exist at the following path:
+      message: stripIndent`
+        ${cmd('readFile', '"{{file}}"')} failed because the file exists when expected not to exist at the following path:
 
-\`{{filePath}}\`\
-`,
-      docsUrl: "https://on.cypress.io/readfile"
+        \`{{filePath}}\``,
+      docsUrl: 'https://on.cypress.io/readfile',
+    },
+    invalid_argument (obj) {
+      return {
+        message: `${cmd('{{cmd}}')} must be passed a non-empty string as its 1st argument. You passed: \`{{file}}\`.`,
+        docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`,
+      }
     },
-    invalid_argument(obj) { return {
-      message: `${cmd('{{cmd}}')} must be passed a non-empty string as its 1st argument. You passed: \`{{file}}\`.`,
-      docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`
-    }; },
     invalid_contents: {
       message: `${cmd('writeFile')} must be passed a non-empty string, an object, or an array as its 2nd argument. You passed: \`{{contents}}\`.`,
-      docsUrl: "https://on.cypress.io/writefile"
+      docsUrl: 'https://on.cypress.io/writefile',
     },
     nonexistent: {
-      message: `${cmd('readFile', '"{{file}}"')} failed because the file does not exist at the following path:
+      message: stripIndent`
+        ${cmd('readFile', '"{{file}}"')} failed because the file does not exist at the following path:
 
-\`{{filePath}}\`\
-`,
-      docsUrl: "https://on.cypress.io/readfile"
+        \`{{filePath}}\``,
+      docsUrl: 'https://on.cypress.io/readfile',
+    },
+    timed_out (obj) {
+      return {
+        message: `${cmd('{{cmd}}', '"{{file}}"')} timed out after waiting \`{{timeout}}ms\`.`,
+        docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`,
+      }
     },
-    timed_out(obj) { return {
-      message: `${cmd('{{cmd}}', '"{{file}}"')} timed out after waiting \`{{timeout}}ms\`.`,
-      docsUrl: `https://on.cypress.io/${_.toLower(obj.cmd)}`
-    }; }
   },
 
   fixture: {
     set_to_false: {
       message: `${cmd('fixture')} is not valid because you have configured \`fixturesFolder\` to \`false\`.`,
-      docsUrl: "https://on.cypress.io/fixture"
+      docsUrl: 'https://on.cypress.io/fixture',
     },
     timed_out: {
       message: `${cmd('fixture')} timed out waiting \`{{timeout}}ms\` to receive a fixture. No fixture was ever sent by the server.`,
-      docsUrl: "https://on.cypress.io/fixture"
-    }
+      docsUrl: 'https://on.cypress.io/fixture',
+    },
   },
 
   focus: {
     invalid_element: {
       message: `${cmd('focus')} can only be called on a valid focusable element. Your subject is a: \`{{node}}\``,
-      docsUrl: "https://on.cypress.io/focus"
+      docsUrl: 'https://on.cypress.io/focus',
     },
     multiple_elements: {
       message: `${cmd('focus')} can only be called on a single element. Your subject contained {{num}} elements.`,
-      docsUrl: "https://on.cypress.io/focus"
+      docsUrl: 'https://on.cypress.io/focus',
     },
     timed_out: {
       message: `${cmd('focus')} timed out because your browser did not receive any \`focus\` events. This is a known bug in Chrome when it is not the currently focused window.`,
-      docsUrl: "https://on.cypress.io/focus"
-    }
+      docsUrl: 'https://on.cypress.io/focus',
+    },
   },
 
   get: {
     alias_invalid: {
-      message: "`{{prop}}` is not a valid alias property. Only `numbers` or `all` is permitted.",
-      docsUrl: "https://on.cypress.io/get"
+      message: '`{{prop}}` is not a valid alias property. Only `numbers` or `all` is permitted.',
+      docsUrl: 'https://on.cypress.io/get',
     },
     alias_zero: {
-      message: "`0` is not a valid alias property. Are you trying to ask for the first response? If so write `@{{alias}}.1`",
-      docsUrl: "https://on.cypress.io/get"
+      message: '`0` is not a valid alias property. Are you trying to ask for the first response? If so write `@{{alias}}.1`',
+      docsUrl: 'https://on.cypress.io/get',
     },
     invalid_options: {
       message: `${cmd('get')} only accepts an options object for its second argument. You passed {{options}}`,
-      docsUrl: "https://on.cypress.io/get"
-    }
+      docsUrl: 'https://on.cypress.io/get',
+    },
   },
 
   getCookie: {
     invalid_argument: {
       message: `${cmd('getCookie')} must be passed a string argument for name.`,
-      docsUrl: "https://on.cypress.io/getcookie"
-    }
+      docsUrl: 'https://on.cypress.io/getcookie',
+    },
   },
 
   go: {
     invalid_argument: {
       message: `${cmd('go')} accepts only a string or number argument`,
-      docsUrl: "https://on.cypress.io/go"
+      docsUrl: 'https://on.cypress.io/go',
     },
     invalid_direction: {
       message: `${cmd('go')} accepts either \`forward\` or \`back\`. You passed: \`{{str}}\``,
-      docsUrl: "https://on.cypress.io/go"
+      docsUrl: 'https://on.cypress.io/go',
     },
     invalid_number: {
       message: `${cmd('go')} cannot accept \`0\`. The number must be greater or less than \`0\`.`,
-      docsUrl: "https://on.cypress.io/go"
-    }
+      docsUrl: 'https://on.cypress.io/go',
+    },
   },
 
   hover: {
     not_implemented: {
-      message: `\
-${cmd('hover')} is not currently implemented.\n
-However it is usually easy to workaround.\n
-Read the following document for a detailed explanation.\n\
-`,
-      docsUrl: "https://on.cypress.io/hover"
-    }
+      message: [
+        `${cmd('hover')} is not currently implemented.`,
+        'However it is usually easy to workaround.',
+        'Read the following document for a detailed explanation.',
+      ].join('\n'),
+      docsUrl: 'https://on.cypress.io/hover',
+    },
   },
   invoke: {
     prop_not_a_function: {
-      message: `\
-${cmd('invoke')} errored because the property: \`{{prop}}\` returned a \`{{type}}\` value instead of a function. ${cmd('invoke')} can only be used on properties that return callable functions.
+      message: stripIndent`\
+        ${cmd('invoke')} errored because the property: \`{{prop}}\` returned a \`{{type}}\` value instead of a function. ${cmd('invoke')} can only be used on properties that return callable functions.
 
-${cmd('invoke')} waited for the specified property \`{{prop}}\` to return a function, but it never did.
+        ${cmd('invoke')} waited for the specified property \`{{prop}}\` to return a function, but it never did.
 
-If you want to assert on the property's value, then switch to use ${cmd('its')} and add an assertion such as:
+        If you want to assert on the property's value, then switch to use ${cmd('its')} and add an assertion such as:
 
-\`cy.wrap({ foo: 'bar' }).its('foo').should('eq', 'bar')\`\
-`,
-      docsUrl: "https://on.cypress.io/invoke"
+        \`cy.wrap({ foo: 'bar' }).its('foo').should('eq', 'bar')\``,
+      docsUrl: 'https://on.cypress.io/invoke',
     },
     subject_null_or_undefined: {
-      message: `\
-${cmd('invoke')} errored because your subject is: \`{{value}}\`. You cannot invoke any functions such as \`{{prop}}\` on a \`{{value}}\` value.
+      message: stripIndent`\
+        ${cmd('invoke')} errored because your subject is: \`{{value}}\`. You cannot invoke any functions such as \`{{prop}}\` on a \`{{value}}\` value.
 
-If you expect your subject to be \`{{value}}\`, then add an assertion such as:
+        If you expect your subject to be \`{{value}}\`, then add an assertion such as:
 
-\`cy.wrap({{value}}).should('be.{{value}}')\`\
-`,
-      docsUrl: "https://on.cypress.io/invoke"
+        \`cy.wrap({{value}}).should('be.{{value}}')\``,
+      docsUrl: 'https://on.cypress.io/invoke',
     },
     null_or_undefined_prop_value: {
-      message: `\
-${cmd('invoke')} errored because the property: \`{{prop}}\` is not a function, and instead returned a \`{{value}}\` value.
+      message: stripIndent`\
+        ${cmd('invoke')} errored because the property: \`{{prop}}\` is not a function, and instead returned a \`{{value}}\` value.
 
-${cmd('invoke')} waited for the specified property \`{{prop}}\` to become a callable function, but it never did.
+        ${cmd('invoke')} waited for the specified property \`{{prop}}\` to become a callable function, but it never did.
 
-If you expect the property \`{{prop}}\` to be \`{{value}}\`, then switch to use ${cmd('its')} and add an assertion such as:
+        If you expect the property \`{{prop}}\` to be \`{{value}}\`, then switch to use ${cmd('its')} and add an assertion such as:
 
-\`cy.wrap({ foo: {{value}} }).its('foo').should('be.{{value}}')\`\
-`,
-      docsUrl: "https://on.cypress.io/invoke"
-    }
+        \`cy.wrap({ foo: {{value}} }).its('foo').should('be.{{value}}')\``,
+      docsUrl: 'https://on.cypress.io/invoke',
+    },
   },
 
   its: {
     subject_null_or_undefined: {
-      message: `\
-${cmd('its')} errored because your subject is: \`{{value}}\`. You cannot access any properties such as \`{{prop}}\` on a \`{{value}}\` value.
+      message: stripIndent`\
+        ${cmd('its')} errored because your subject is: \`{{value}}\`. You cannot access any properties such as \`{{prop}}\` on a \`{{value}}\` value.
 
-If you expect your subject to be \`{{value}}\`, then add an assertion such as:
+        If you expect your subject to be \`{{value}}\`, then add an assertion such as:
 
-\`cy.wrap({{value}}).should('be.{{value}}')\`\
-`,
-      docsUrl: "https://on.cypress.io/its"
+        \`cy.wrap({{value}}).should('be.{{value}}')\``,
+      docsUrl: 'https://on.cypress.io/its',
     },
     null_or_undefined_prop_value: {
-      message: `\
-${cmd('its')} errored because the property: \`{{prop}}\` returned a \`{{value}}\` value.
+      message: stripIndent`\
+        ${cmd('its')} errored because the property: \`{{prop}}\` returned a \`{{value}}\` value.
 
-${cmd('its')} waited for the specified property \`{{prop}}\` to become accessible, but it never did.
+        ${cmd('its')} waited for the specified property \`{{prop}}\` to become accessible, but it never did.
 
-If you expect the property \`{{prop}}\` to be \`{{value}}\`, then add an assertion such as:
+        If you expect the property \`{{prop}}\` to be \`{{value}}\`, then add an assertion such as:
 
-\`cy.wrap({ foo: {{value}} }).its('foo').should('be.{{value}}')\`\
-`,
-      docsUrl: "https://on.cypress.io/its"
-    }
+        \`cy.wrap({ foo: {{value}} }).its('foo').should('be.{{value}}')\``,
+      docsUrl: 'https://on.cypress.io/its',
+    },
   },
 
   invoke_its: {
     nonexistent_prop: {
-      message: `\
-${cmd('{{cmd}}')} errored because the property: \`{{prop}}\` does not exist on your subject.
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} errored because the property: \`{{prop}}\` does not exist on your subject.
 
-${cmd('{{cmd}}')} waited for the specified property \`{{prop}}\` to exist, but it never did.
+        ${cmd('{{cmd}}')} waited for the specified property \`{{prop}}\` to exist, but it never did.
 
-If you do not expect the property \`{{prop}}\` to exist, then add an assertion such as:
+        If you do not expect the property \`{{prop}}\` to exist, then add an assertion such as:
 
-\`cy.wrap({ foo: 'bar' }).its('quux').should('not.exist')\`\
-`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+        \`cy.wrap({ foo: 'bar' }).its('quux').should('not.exist')\``,
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     previous_prop_null_or_undefined: {
-      message: `\
-${cmd('{{cmd}}')} errored because the property: \`{{previousProp}}\` returned a \`{{value}}\` value. The property: \`{{prop}}\` does not exist on a \`{{value}}\` value.
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} errored because the property: \`{{previousProp}}\` returned a \`{{value}}\` value. The property: \`{{prop}}\` does not exist on a \`{{value}}\` value.
 
-${cmd('{{cmd}}')} waited for the specified property \`{{prop}}\` to become accessible, but it never did.
+        ${cmd('{{cmd}}')} waited for the specified property \`{{prop}}\` to become accessible, but it never did.
 
-If you do not expect the property \`{{prop}}\` to exist, then add an assertion such as:
+        If you do not expect the property \`{{prop}}\` to exist, then add an assertion such as:
 
-\`cy.wrap({ foo: {{value}} }).its('foo.baz').should('not.exist')\`\
-`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+        \`cy.wrap({ foo: {{value}} }).its('foo.baz').should('not.exist')\``,
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     invalid_1st_arg: {
       message: `${cmd('{{cmd}}')} only accepts a string as the first argument.`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     invalid_num_of_args: {
-      message: `\
-${cmd('{{cmd}}')} does not accept additional arguments.
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} does not accept additional arguments.
 
-If you want to invoke a function with arguments, use \`.invoke()\`.\
-`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+        If you want to invoke a function with arguments, use \`.invoke()\`.`,
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     invalid_options_arg: {
       message: `${cmd('{{cmd}}')} only accepts an object as the options argument.`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     invalid_prop_name_arg: {
       message: `${cmd('{{cmd}}')} only accepts a string or a number as the {{identifier}}Name argument.`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     null_or_undefined_property_name: {
       message: `${cmd('{{cmd}}')} expects the {{identifier}}Name argument to have a value.`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
     },
     timed_out: {
-      message: `\
-${cmd('{{cmd}}')} timed out after waiting \`{{timeout}}ms\`.
+      message: stripIndent`\
+        ${cmd('{{cmd}}')} timed out after waiting \`{{timeout}}ms\`.
 
-Your callback function returned a promise which never resolved.
+        Your callback function returned a promise which never resolved.
 
-The callback function was:
+        The callback function was:
 
-{{func}}\
-`,
-      docsUrl: "https://on.cypress.io/{{cmd}}"
-    }
+        {{func}}`,
+      docsUrl: 'https://on.cypress.io/{{cmd}}',
+    },
   },
   location: {
     invalid_key: {
-      message: "Location object does not have key: `{{key}}`",
-      docsUrl: "https://on.cypress.io/location"
-    }
+      message: 'Location object does not have key: `{{key}}`',
+      docsUrl: 'https://on.cypress.io/location',
+    },
   },
 
   log: {
     invalid_argument: {
-      message: "`Cypress.log()` can only be called with an options object. Your argument was: `{{arg}}`",
-      docsUrl: "https://on.cypress.io/cypress-log"
-    }
+      message: '`Cypress.log()` can only be called with an options object. Your argument was: `{{arg}}`',
+      docsUrl: 'https://on.cypress.io/cypress-log',
+    },
   },
 
   miscellaneous: {
-    custom_command_interface_changed(obj) { return {
-      message: `\
-Cypress.${obj.method}(...) has been removed and replaced by:
+    custom_command_interface_changed (obj) {
+      return {
+        message: stripIndent`\
+          Cypress.${obj.method}(...) has been removed and replaced by:
 
-\`Cypress.Commands.add(...)\`
+          \`Cypress.Commands.add(...)\`
 
-Instead of indicating \`parent\`, \`child\`, or \`dual\` commands, you pass an \`options\` object
-to describe the requirements around the previous subject. You can also enforce specific
-subject types such as requiring the subject to be a DOM element.
+          Instead of indicating \`parent\`, \`child\`, or \`dual\` commands, you pass an \`options\` object
+          to describe the requirements around the previous subject. You can also enforce specific
+          subject types such as requiring the subject to be a DOM element.
 
-To rewrite this custom command you'd likely write:
+          To rewrite this custom command you'd likely write:
 
-\`Cypress.Commands.add(${obj.signature})\`\
-`,
-      docsUrl: "https://on.cypress.io/custom-command-interface-changed"
-    }; },
-    returned_value_and_commands_from_custom_command(obj) { return {
-      message: `\
-Cypress detected that you invoked one or more cy commands in a custom command but returned a different value.
+          \`Cypress.Commands.add(${obj.signature})\``,
+        docsUrl: 'https://on.cypress.io/custom-command-interface-changed',
+      }
+    },
+    returned_value_and_commands_from_custom_command (obj) {
+      return {
+        message: stripIndent`\
+          Cypress detected that you invoked one or more cy commands in a custom command but returned a different value.
 
-The custom command was:
+          The custom command was:
 
-  > ${cmd(obj.current)}
+            > ${cmd(obj.current)}
 
-The return value was:
+          The return value was:
 
-  > ${obj.returned}
+            > ${obj.returned}
 
-Because cy commands are asynchronous and are queued to be run later, it doesn't make sense to return anything else.
+          Because cy commands are asynchronous and are queued to be run later, it doesn't make sense to return anything else.
 
-For convenience, you can also simply omit any return value or return \`undefined\` and Cypress will not error.
+          For convenience, you can also simply omit any return value or return \`undefined\` and Cypress will not error.
 
-In previous versions of Cypress we automatically detected this and forced the cy commands to be returned. To make things less magical and clearer, we are now throwing an error.\
-`,
-      docsUrl: "https://on.cypress.io/returning-value-and-commands-in-custom-command"
-    }; },
-    returned_value_and_commands(obj) { return {
-      message: `\
-Cypress detected that you invoked one or more cy commands but returned a different value.
+          In previous versions of Cypress we automatically detected this and forced the cy commands to be returned. To make things less magical and clearer, we are now throwing an error.`,
+        docsUrl: 'https://on.cypress.io/returning-value-and-commands-in-custom-command',
+      }
+    },
+    returned_value_and_commands (obj) {
+      return {
+        message: stripIndent`\
+          Cypress detected that you invoked one or more cy commands but returned a different value.
 
-The return value was:
+          The return value was:
 
-  > ${obj.returned}
+            > ${obj.returned}
 
-Because cy commands are asynchronous and are queued to be run later, it doesn't make sense to return anything else.
+          Because cy commands are asynchronous and are queued to be run later, it doesn't make sense to return anything else.
 
-For convenience, you can also simply omit any return value or return \`undefined\` and Cypress will not error.
+          For convenience, you can also simply omit any return value or return \`undefined\` and Cypress will not error.
 
-In previous versions of Cypress we automatically detected this and forced the cy commands to be returned. To make things less magical and clearer, we are now throwing an error.\
-`,
-      docsUrl: "https://on.cypress.io/returning-value-and-commands-in-test"
-    }; },
-    command_returned_promise_and_commands(obj) { return {
-      message: `\
-Cypress detected that you returned a promise from a command while also invoking one or more cy commands in that promise.
+          In previous versions of Cypress we automatically detected this and forced the cy commands to be returned. To make things less magical and clearer, we are now throwing an error.`,
+        docsUrl: 'https://on.cypress.io/returning-value-and-commands-in-test',
+      }
+    },
+    command_returned_promise_and_commands (obj) {
+      return {
+        message: stripIndent`\
+          Cypress detected that you returned a promise from a command while also invoking one or more cy commands in that promise.
 
-The command that returned the promise was:
+          The command that returned the promise was:
 
-  > ${cmd(obj.current)}
+            > ${cmd(obj.current)}
 
-The cy command you invoked inside the promise was:
+          The cy command you invoked inside the promise was:
 
-  > ${cmd(obj.called)}
+            > ${cmd(obj.called)}
 
-Because Cypress commands are already promise-like, you don't need to wrap them or return your own promise.
+          Because Cypress commands are already promise-like, you don't need to wrap them or return your own promise.
 
-Cypress will resolve your command with whatever the final Cypress command yields.
+          Cypress will resolve your command with whatever the final Cypress command yields.
 
-The reason this is an error instead of a warning is because Cypress internally queues commands serially whereas Promises execute as soon as they are invoked. Attempting to reconcile this would prevent Cypress from ever resolving.\
-`,
-      docsUrl: "https://on.cypress.io/returning-promise-and-commands-in-another-command"
-    }; },
-    mixing_promises_and_commands(obj) { return {
-      message: `\
-Cypress detected that you returned a promise in a test, but also invoked one or more cy commands inside of that promise.
+          The reason this is an error instead of a warning is because Cypress internally queues commands serially whereas Promises execute as soon as they are invoked. Attempting to reconcile this would prevent Cypress from ever resolving.`,
+        docsUrl: 'https://on.cypress.io/returning-promise-and-commands-in-another-command',
+      }
+    },
+    mixing_promises_and_commands (obj) {
+      return {
+        message: stripIndent`\
+          Cypress detected that you returned a promise in a test, but also invoked one or more cy commands inside of that promise.
 
-The test title was:
+          The test title was:
 
-  > ${obj.title}
+            > ${obj.title}
 
-While this works in practice, it's often indicative of an anti-pattern. You almost never need to return both a promise and also invoke cy commands.
+          While this works in practice, it's often indicative of an anti-pattern. You almost never need to return both a promise and also invoke cy commands.
 
-Cy commands themselves are already promise like, and you can likely avoid the use of the separate Promise.\
-`,
-      docsUrl: "https://on.cypress.io/returning-promise-and-commands-in-test"
-    }; },
-    command_log_renamed: `\
-\`Cypress.Log.command()\` has been renamed to \`Cypress.log()\`
+          Cy commands themselves are already promise like, and you can likely avoid the use of the separate Promise.`,
+        docsUrl: 'https://on.cypress.io/returning-promise-and-commands-in-test',
+      }
+    },
+    command_log_renamed: stripIndent`\
+      \`Cypress.Log.command()\` has been renamed to \`Cypress.log()\`
 
-Please update your code. You should be able to safely do a find/replace.\
-`,
+      Please update your code. You should be able to safely do a find/replace.`,
     dangling_commands: {
-      message: `\
-Oops, Cypress detected something wrong with your test code.
+      message: stripIndent`\
+        Oops, Cypress detected something wrong with your test code.
 
-The test has finished but Cypress still has commands in its queue.
-The {{numCommands}} queued commands that have not yet run are:
+        The test has finished but Cypress still has commands in its queue.
+        The {{numCommands}} queued commands that have not yet run are:
 
-{{commands}}
+        {{commands}}
 
-In every situation we've seen, this has been caused by programmer error.
+        In every situation we've seen, this has been caused by programmer error.
 
-Most often this indicates a race condition due to a forgotten 'return' or from commands in a previously run test bleeding into the current test.
+        Most often this indicates a race condition due to a forgotten 'return' or from commands in a previously run test bleeding into the current test.
 
-For a much more thorough explanation including examples please review this error here:\
-`,
-      docsUrl: "https://on.cypress.io/command-queue-ended-early"
+        For a much more thorough explanation including examples please review this error here:`,
+      docsUrl: 'https://on.cypress.io/command-queue-ended-early',
     },
     invalid_command: {
-      message: "Could not find a command for: `{{name}}`.\n\nAvailable commands are: {{cmds}}.\n",
-      docsUrl: "https://on.cypress.io/api"
+      message: 'Could not find a command for: `{{name}}`.\n\nAvailable commands are: {{cmds}}.\n',
+      docsUrl: 'https://on.cypress.io/api',
     },
     invalid_overwrite: {
-      message: "Cannot overwite command for: `{{name}}`. An existing command does not exist by that name.",
-      docsUrl: "https://on.cypress.io/api"
+      message: 'Cannot overwite command for: `{{name}}`. An existing command does not exist by that name.',
+      docsUrl: 'https://on.cypress.io/api',
     },
-    invoking_child_without_parent(obj) {
-      return `\
-Oops, it looks like you are trying to call a child command before running a parent command.
+    invoking_child_without_parent (obj) {
+      return stripIndent`\
+        Oops, it looks like you are trying to call a child command before running a parent command.
 
-You wrote code that looks like this:
+        You wrote code that looks like this:
 
-\`${cmd(obj.cmd, obj.args)}\`
+        \`${cmd(obj.cmd, obj.args)}\`
 
-A child command must be chained after a parent because it operates on a previous subject.
+        A child command must be chained after a parent because it operates on a previous subject.
 
-For example - if we were issuing the child command \`click\`...
+        For example - if we were issuing the child command \`click\`...
 
-cy
-  .get('button') // parent command must come first
-  .click()       // then child command comes second\
-`;
+        cy
+          .get('button') // parent command must come first
+          .click()       // then child command comes second`
     },
-    no_cy: "`Cypress.cy` is `undefined`. You may be trying to query outside of a running test. Cannot call `Cypress.$()`",
-    no_runner: "Cannot call `Cypress#run` without a runner instance.",
+    no_cy: '`Cypress.cy` is `undefined`. You may be trying to query outside of a running test. Cannot call `Cypress.$()`',
+    no_runner: 'Cannot call `Cypress#run` without a runner instance.',
     outside_test: {
-      message: `\
-Cypress cannot execute commands outside a running test.
+      message: stripIndent`\
+        Cypress cannot execute commands outside a running test.
 
-This usually happens when you accidentally write commands outside an \`it(...)\` test.
+        This usually happens when you accidentally write commands outside an \`it(...)\` test.
 
-If that is the case, just move these commands inside an \`it(...)\` test.
+        If that is the case, just move these commands inside an \`it(...)\` test.
 
-Check your test file for errors.\
-`,
-      docsUrl: "https://on.cypress.io/cannot-execute-commands-outside-test"
+        Check your test file for errors.`,
+      docsUrl: 'https://on.cypress.io/cannot-execute-commands-outside-test',
     },
     outside_test_with_cmd: {
-      message: `\
-Cannot call ${cmd('{{cmd}}')} outside a running test.
+      message: stripIndent`\
+        Cannot call ${cmd('{{cmd}}')} outside a running test.
 
-This usually happens when you accidentally write commands outside an \`it(...)\` test.
+        This usually happens when you accidentally write commands outside an \`it(...)\` test.
 
-If that is the case, just move these commands inside an \`it(...)\` test.
+        If that is the case, just move these commands inside an \`it(...)\` test.
 
-Check your test file for errors.\
-`,
-      docsUrl: "https://on.cypress.io/cannot-execute-commands-outside-test"
+        Check your test file for errors.`,
+      docsUrl: 'https://on.cypress.io/cannot-execute-commands-outside-test',
     },
-    private_custom_command_interface: "You cannot use the undocumented private command interface: `{{method}}`",
-    private_property:
-      `\
-You are accessing a private property directly on \`cy\` which has been renamed.
+    private_custom_command_interface: 'You cannot use the undocumented private command interface: `{{method}}`',
+    private_property: stripIndent`\
+      You are accessing a private property directly on \`cy\` which has been renamed.
 
-This was never documented nor supported.
+      This was never documented nor supported.
 
-Please go through the public function: ${cmd('state', "...")}\
-`,
-    retry_timed_out: "Timed out retrying: "
+      Please go through the public function: ${cmd('state', '...')}`,
+    retry_timed_out: 'Timed out retrying: ',
   },
 
   mocha: {
-    async_timed_out: "Timed out after `{{ms}}ms`. The `done()` callback was never invoked!",
-    invalid_interface: "Invalid mocha interface `{{name}}`",
-    timed_out: "Cypress command timeout of `{{ms}}ms` exceeded.",
+    async_timed_out: 'Timed out after `{{ms}}ms`. The `done()` callback was never invoked!',
+    invalid_interface: 'Invalid mocha interface `{{name}}`',
+    timed_out: 'Cypress command timeout of `{{ms}}ms` exceeded.',
     overspecified: {
-      message: `\
-Cypress detected that you returned a promise in a test, but also invoked a done callback. Return a promise -or- invoke a done callback, not both.
+      message: stripIndent`\
+        Cypress detected that you returned a promise in a test, but also invoked a done callback. Return a promise -or- invoke a done callback, not both.
 
-Original mocha error:
+        Original mocha error:
 
-{{error}}\
-`,
-      docsUrl: "https://on.cypress.io/returning-promise-and-invoking-done-callback"
-    }
+        {{error}}`,
+      docsUrl: 'https://on.cypress.io/returning-promise-and-invoking-done-callback',
+    },
   },
 
   navigation: {
-    cross_origin({ message, originPolicy, configFile }) { return {
-      message: `\
-Cypress detected a cross origin error happened on page load:
+    cross_origin ({ message, originPolicy, configFile }) {
+      return {
+        message: stripIndent`\
+          Cypress detected a cross origin error happened on page load:
 
-  > ${message}
+            > ${message}
 
-Before the page load, you were bound to the origin policy:
+          Before the page load, you were bound to the origin policy:
 
-  > ${originPolicy}
+            > ${originPolicy}
 
-A cross origin error happens when your application navigates to a new URL which does not match the origin policy above.
+          A cross origin error happens when your application navigates to a new URL which does not match the origin policy above.
 
-A new URL does not match the origin policy if the 'protocol', 'port' (if specified), and/or 'host' (unless of the same superdomain) are different.
+          A new URL does not match the origin policy if the 'protocol', 'port' (if specified), and/or 'host' (unless of the same superdomain) are different.
 
-Cypress does not allow you to navigate to a different origin URL within a single test.
+          Cypress does not allow you to navigate to a different origin URL within a single test.
 
-You may need to restructure some of your test code to avoid this problem.
+          You may need to restructure some of your test code to avoid this problem.
 
-Alternatively you can also disable Chrome Web Security in Chromium-based browsers which will turn off this restriction by setting { chromeWebSecurity: false } in ${formatConfigFile(configFile)}.\
-`,
-      docsUrl: "https://on.cypress.io/cross-origin-violation"
-    }; },
-    timed_out({ ms, configFile }) { return `\
-Timed out after waiting \`${ms}ms\` for your remote page to load.
+          Alternatively you can also disable Chrome Web Security in Chromium-based browsers which will turn off this restriction by setting { chromeWebSecurity: false } in ${formatConfigFile(configFile)}.`,
+        docsUrl: 'https://on.cypress.io/cross-origin-violation',
+      }
+    },
+    timed_out ({ ms, configFile }) {
+      return stripIndent`\
+        Timed out after waiting \`${ms}ms\` for your remote page to load.
 
-Your page did not fire its \`load\` event within \`${ms}ms\`.
+        Your page did not fire its \`load\` event within \`${ms}ms\`.
 
-You can try increasing the \`pageLoadTimeout\` value in ${formatConfigFile(configFile)} to wait longer.
+        You can try increasing the \`pageLoadTimeout\` value in ${formatConfigFile(configFile)} to wait longer.
 
-Browsers will not fire the \`load\` event until all stylesheets and scripts are done downloading.
+        Browsers will not fire the \`load\` event until all stylesheets and scripts are done downloading.
 
-When this \`load\` event occurs, Cypress will continue running commands.\
-`; }
+        When this \`load\` event occurs, Cypress will continue running commands.`
+    },
   },
 
   ng: {
-    no_global: `Angular global (\`window.angular\`) was not found in your window. You cannot use ${cmd('ng')} methods without angular.`
+    no_global: `Angular global (\`window.angular\`) was not found in your window. You cannot use ${cmd('ng')} methods without angular.`,
   },
 
   proxy: {
-    js_rewriting_failed: `\
-An error occurred in the Cypress proxy layer while rewriting your source code. This is a bug in Cypress. Open an issue if you see this message.
+    js_rewriting_failed: stripIndent`\
+      An error occurred in the Cypress proxy layer while rewriting your source code. This is a bug in Cypress. Open an issue if you see this message.
 
-JS URL: {{url}}
+      JS URL: {{url}}
 
-Original error:
+      Original error:
 
-{{errMessage}}
-{{errStack}}\
-`
+      {{errMessage}}
+      {{errStack}}`,
   },
 
   reload: {
     invalid_arguments: {
       message: `${cmd('reload')} can only accept a boolean or \`options\` as its arguments.`,
-      docsUrl: "https://on.cypress.io/reload"
-    }
+      docsUrl: 'https://on.cypress.io/reload',
+    },
   },
 
   request: {
-    body_circular({ path }) { return {
-      message: `\
-The \`body\` parameter supplied to ${cmd('request')} contained a circular reference at the path "${path.join(".")}".
-
-\`body\` can only be a string or an object with no circular references.\
-`,
-      docsUrl: "https://on.cypress.io/request"
-    }; },
+    body_circular ({ path }) {
+      return {
+        message: stripIndent`\
+          The \`body\` parameter supplied to ${cmd('request')} contained a circular reference at the path "${path.join('.')}".
+
+          \`body\` can only be a string or an object with no circular references.`,
+        docsUrl: 'https://on.cypress.io/request',
+      }
+    },
     status_code_flags_invalid: {
-      message: `\
-${cmd('request')} was invoked with \`{ failOnStatusCode: false, retryOnStatusCodeFailure: true }\`.
+      message: stripIndent`\
+        ${cmd('request')} was invoked with \`{ failOnStatusCode: false, retryOnStatusCodeFailure: true }\`.
 
-These options are incompatible with each other.
+        These options are incompatible with each other.
 
-- To retry on non-2xx status codes, pass \`{ failOnStatusCode: true, retryOnStatusCodeFailure: true }\`.
-- To not retry on non-2xx status codes, pass \`{ failOnStatusCode: true, retryOnStatusCodeFailure: true }\`.
-- To fail on non-2xx status codes without retrying (the default behavior), pass \`{ failOnStatusCode: true, retryOnStatusCodeFailure: false }\`\
-`,
-      docsUrl: "https://on.cypress.io/request"
+        - To retry on non-2xx status codes, pass \`{ failOnStatusCode: true, retryOnStatusCodeFailure: true }\`.
+        - To not retry on non-2xx status codes, pass \`{ failOnStatusCode: true, retryOnStatusCodeFailure: true }\`.
+        - To fail on non-2xx status codes without retrying (the default behavior), pass \`{ failOnStatusCode: true, retryOnStatusCodeFailure: false }\``,
+      docsUrl: 'https://on.cypress.io/request',
     },
     auth_invalid: {
       message: `${cmd('request')} must be passed an object literal for the \`auth\` option.`,
-      docsUrl: "https://on.cypress.io/request"
+      docsUrl: 'https://on.cypress.io/request',
     },
     gzip_invalid: {
       message: `${cmd('request')} requires the \`gzip\` option to be a boolean.`,
-      docsUrl: "https://on.cypress.io/request"
+      docsUrl: 'https://on.cypress.io/request',
     },
     headers_invalid: {
       message: `${cmd('request')} requires the \`headers\` option to be an object literal.`,
-      docsUrl: "https://on.cypress.io/request"
+      docsUrl: 'https://on.cypress.io/request',
     },
     invalid_method: {
       message: `${cmd('request')} was called with an invalid method: \`{{method}}\`. Method can be: \`GET\`, \`POST\`, \`PUT\`, \`DELETE\`, \`PATCH\`, \`HEAD\`, \`OPTIONS\`, or any other method supported by Node's HTTP parser.`,
-      docsUrl: "https://on.cypress.io/request"
+      docsUrl: 'https://on.cypress.io/request',
     },
     failonstatus_deprecated_warning: {
       message: `The ${cmd('request')} \`failOnStatus\` option has been renamed to \`failOnStatusCode\`. Please update your code. This option will be removed at a later time.`,
-      docsUrl: "https://on.cypress.io/request"
+      docsUrl: 'https://on.cypress.io/request',
     },
     form_invalid: {
-      message: `\
-${cmd('request')} requires the \`form\` option to be a boolean.
+      message: stripIndent`\
+        ${cmd('request')} requires the \`form\` option to be a boolean.
 
-If you're trying to send a \`x-www-form-urlencoded\` request then pass either a string or object literal to the \`body\` property.\
-`,
-      docsUrl: "https://on.cypress.io/request"
+        If you're trying to send a \`x-www-form-urlencoded\` request then pass either a string or object literal to the \`body\` property.`,
+      docsUrl: 'https://on.cypress.io/request',
     },
-    loading_failed(obj) { return {
-      message: `\
-${cmd('request')} failed trying to load:
+    /* eslint-disable indent */
+    loading_failed (obj) {
+      return {
+        message: cyStripIndent(`\
+          ${cmd('request')} failed trying to load:
 
-${obj.url}
+          ${obj.url}
 
-We attempted to make an http request to this URL but the request failed without a response.
+          We attempted to make an http request to this URL but the request failed without a response.
 
-We received this error at the network level:
+          We received this error at the network level:
 
-  > ${obj.error}
+            > ${obj.error}
 
-${divider(60, '-')}
+          ${divider(60, '-')}
 
-The request we sent was:
+          The request we sent was:
 
-${getHttpProps([
-          {key: 'method',    value: obj.method},
-          {key: 'URL',       value: obj.url},
-        ])}
+          ${getHttpProps([
+            { key: 'method', value: obj.method },
+            { key: 'URL', value: obj.url },
+          ])}
 
-${divider(60, '-')}
+          ${divider(60, '-')}
 
-Common situations why this would fail:
-  - you don't have internet access
-  - you forgot to run / boot your web server
-  - your web server isn't accessible
-  - you have weird network configuration settings on your computer\
-`,
-      docsUrl: "https://on.cypress.io/request"
-    }; },
-    status_invalid(obj) { return {
-      message: `\
-${cmd('request')} failed on:
+          Common situations why this would fail:
+            - you don't have internet access
+            - you forgot to run / boot your web server
+            - your web server isn't accessible
+            - you have weird network configuration settings on your computer`, 10),
+        docsUrl: 'https://on.cypress.io/request',
+      }
+    },
+    status_invalid (obj) {
+      return {
+        message: cyStripIndent(`\
+          ${cmd('request')} failed on:
 
-${obj.url}
+          ${obj.url}
 
-The response we received from your web server was:
+          The response we received from your web server was:
 
-  > ${obj.status}: ${obj.statusText}
+            > ${obj.status}: ${obj.statusText}
 
-This was considered a failure because the status code was not \`2xx\` or \`3xx\`.
+          This was considered a failure because the status code was not \`2xx\` or \`3xx\`.
 
-If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`
+          If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`
 
-${divider(60, '-')}
+          ${divider(60, '-')}
 
-The request we sent was:
+          The request we sent was:
 
-${getHttpProps([
-          {key: 'method',    value: obj.method},
-          {key: 'URL',       value: obj.url},
-          {key: 'headers',   value: obj.requestHeaders},
-          {key: 'body',      value: obj.requestBody},
-          {key: 'redirects', value: obj.redirects}
-        ])}
+          ${getHttpProps([
+              { key: 'method', value: obj.method },
+              { key: 'URL', value: obj.url },
+              { key: 'headers', value: obj.requestHeaders },
+              { key: 'body', value: obj.requestBody },
+              { key: 'redirects', value: obj.redirects },
+            ])}
 
-${divider(60, '-')}
+          ${divider(60, '-')}
 
-The response we got was:
+          The response we got was:
 
-${getHttpProps([
-          {key: 'status',  value: obj.status + ' - ' + obj.statusText},
-          {key: 'headers', value: obj.responseHeaders},
-          {key: 'body',    value: obj.responseBody}
-        ])}
-\
-`,
-      docsUrl: "https://on.cypress.io/request"
-    }; },
-    timed_out(obj) { return {
-      message: `\
-${cmd('request')} timed out waiting \`${obj.timeout}ms\` for a response from your server.
+          ${getHttpProps([
+              { key: 'status', value: `${obj.status} - ${obj.statusText}` },
+              { key: 'headers', value: obj.responseHeaders },
+              { key: 'body', value: obj.responseBody },
+            ])}`, 10),
+        docsUrl: 'https://on.cypress.io/request',
+      }
+    },
+    timed_out (obj) {
+      return {
+        message: cyStripIndent(`\
+          ${cmd('request')} timed out waiting \`${obj.timeout}ms\` for a response from your server.
 
-The request we sent was:
+          The request we sent was:
 
-${getHttpProps([
-          {key: 'method',    value: obj.method},
-          {key: 'URL',       value: obj.url},
-        ])}
+          ${getHttpProps([
+              { key: 'method', value: obj.method },
+              { key: 'URL', value: obj.url },
+            ])}
 
-No response was received within the timeout.\
-`,
-      docsUrl: "https://on.cypress.io/request"
-    }; },
+          No response was received within the timeout.`, 10),
+        docsUrl: 'https://on.cypress.io/request',
+      }
+    },
+    /* eslint-enable indent */
     url_missing: {
       message: `${cmd('request')} requires a \`url\`. You did not provide a \`url\`.`,
-      docsUrl: "https://on.cypress.io/request"
+      docsUrl: 'https://on.cypress.io/request',
+    },
+    url_invalid ({ configFile }) {
+      return {
+        message: `${cmd('request')} must be provided a fully qualified \`url\` - one that begins with \`http\`. By default ${cmd('request')} will use either the current window's origin or the \`baseUrl\` in ${formatConfigFile(configFile)}. Neither of those values were present.`,
+        docsUrl: 'https://on.cypress.io/request',
+      }
     },
-    url_invalid({ configFile }) { return {
-      message: `${cmd('request')} must be provided a fully qualified \`url\` - one that begins with \`http\`. By default ${cmd('request')} will use either the current window's origin or the \`baseUrl\` in ${formatConfigFile(configFile)}. Neither of those values were present.`,
-      docsUrl: "https://on.cypress.io/request"
-    }; },
     url_wrong_type: {
       message: `${cmd('request')} requires the \`url\` to be a string.`,
-      docsUrl: "https://on.cypress.io/request"
-    }
+      docsUrl: 'https://on.cypress.io/request',
+    },
   },
 
   route: {
     failed_prerequisites: {
       message: `${cmd('route')} cannot be invoked before starting the ${cmd('server')}`,
-      docsUrl: "https://on.cypress.io/server"
+      docsUrl: 'https://on.cypress.io/server',
     },
     invalid_arguments: {
       message: `${cmd('route')} was not provided any arguments. You must provide valid arguments.`,
-      docsUrl: "https://on.cypress.io/route"
+      docsUrl: 'https://on.cypress.io/route',
     },
     method_invalid: {
       message: `${cmd('route')} was called with an invalid method: \`{{method}}\`. Method can be: \`GET\`, \`POST\`, \`PUT\`, \`DELETE\`, \`PATCH\`, \`HEAD\`, \`OPTIONS\`, or any other method supported by Node's HTTP parser.`,
-      docsUrl: "https://on.cypress.io/route"
+      docsUrl: 'https://on.cypress.io/route',
     },
     response_invalid: {
       message: `${cmd('route')} cannot accept an \`undefined\` or \`null\` response. It must be set to something, even an empty string will work.`,
-      docsUrl: "https://on.cypress.io/route"
+      docsUrl: 'https://on.cypress.io/route',
     },
     url_invalid: {
       message: `${cmd('route')} was called with an invalid \`url\`. \`url\` must be either a string or regular expression.`,
-      docsUrl: "https://on.cypress.io/route"
+      docsUrl: 'https://on.cypress.io/route',
     },
     url_missing: {
       message: `${cmd('route')} must be called with a \`url\`. It can be a string or regular expression.`,
-      docsUrl: "https://on.cypress.io/route"
+      docsUrl: 'https://on.cypress.io/route',
     },
-    url_percentencoding_warning({ decodedUrl }) { return {
-      message: `\
-A \`url\` with percent-encoded characters was passed to ${cmd('route')}, but ${cmd('route')} expects a decoded \`url\`.
+    url_percentencoding_warning ({ decodedUrl }) {
+      return {
+        message: stripIndent`\
+          A \`url\` with percent-encoded characters was passed to ${cmd('route')}, but ${cmd('route')} expects a decoded \`url\`.
 
-Did you mean to pass "${decodedUrl}"?\
-`,
-      docsUrl: "https://on.cypress.io/route"
-    }; }
+          Did you mean to pass "${decodedUrl}"?`,
+        docsUrl: 'https://on.cypress.io/route',
+      }
+    },
   },
 
   scrollIntoView: {
     invalid_argument: {
       message: `${cmd('scrollIntoView')} can only be called with an \`options\` object. Your argument was: \`{{arg}}\``,
-      docsUrl: "https://on.cypress.io/scrollintoview"
+      docsUrl: 'https://on.cypress.io/scrollintoview',
     },
     multiple_elements: {
       message: `${cmd('scrollIntoView')} can only be used to scroll to 1 element, you tried to scroll to {{num}} elements.\n\n`,
-      docsUrl: "https://on.cypress.io/scrollintoview"
+      docsUrl: 'https://on.cypress.io/scrollintoview',
     },
     invalid_easing: {
       message: `${cmd('scrollIntoView')} must be called with a valid \`easing\`. Your easing was: \`{{easing}}\``,
-      docsUrl: "https://on.cypress.io/scrollintoview"
+      docsUrl: 'https://on.cypress.io/scrollintoview',
     },
     invalid_duration: {
       message: `${cmd('scrollIntoView')} must be called with a valid \`duration\`. Duration may be either a number (ms) or a string representing a number (ms). Your duration was: \`{{duration}}\``,
-      docsUrl: "https://on.cypress.io/scrollintoview"
-    }
+      docsUrl: 'https://on.cypress.io/scrollintoview',
+    },
   },
 
   scrollTo: {
     animation_failed: {
       message: `${cmd('scrollTo')} failed to scroll.`,
-      docsUrl: "https://on.cypress.io/scrollto"
+      docsUrl: 'https://on.cypress.io/scrollto',
     },
     invalid_easing: {
       message: `${cmd('scrollTo')} must be called with a valid \`easing\`. Your easing was: \`{{easing}}\``,
-      docsUrl: "https://on.cypress.io/scrollto"
+      docsUrl: 'https://on.cypress.io/scrollto',
     },
     invalid_duration: {
       message: `${cmd('scrollTo')} must be called with a valid \`duration\`. Duration may be either a number (ms) or a string representing a number (ms). Your duration was: \`{{duration}}\``,
-      docsUrl: "https://on.cypress.io/scrollto"
+      docsUrl: 'https://on.cypress.io/scrollto',
     },
     invalid_target: {
       message: `${cmd('scrollTo')} must be called with a valid \`position\`. It can be a string, number or object. Your position was: \`{{x}}, {{y}}\``,
-      docsUrl: "https://on.cypress.io/scrollto"
+      docsUrl: 'https://on.cypress.io/scrollto',
     },
     multiple_containers: {
       message: `${cmd('scrollTo')} can only be used to scroll 1 element, you tried to scroll {{num}} elements.\n\n`,
-      docsUrl: "https://on.cypress.io/scrollto"
-    }
+      docsUrl: 'https://on.cypress.io/scrollto',
+    },
   },
 
   screenshot: {
-    invalid_arg(obj) { return {
-      message: `${cmd(obj.cmd)} must be called with an object. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
-    invalid_capture(obj) { return {
-      message: `${cmd(obj.cmd)} \`capture\` option must be one of the following: \`fullPage\`, \`viewport\`, or \`runner\`. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
-    invalid_boolean(obj) { return {
-      message: `${cmd(obj.cmd)} \`{{option}}\` option must be a boolean. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
-    invalid_blackout(obj) { return {
-      message: `${cmd(obj.cmd)} \`blackout\` option must be an array of strings. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
-    invalid_callback(obj) { return {
-      message: `${cmd(obj.cmd)} \`{{callback}}\` option must be a function. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
-    invalid_clip(obj) { return {
-      message: `${cmd(obj.cmd)} \`clip\` option must be an object with the keys \`{ width, height, x, y }\` and number values. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
-    invalid_height(obj) { return {
-      message: `${cmd('screenshot')} only works with a screenshot area with a height greater than zero.`,
-      docsUrl: "https://on.cypress.io/screenshot"
-    }; },
-    invalid_padding(obj) { return {
-      message: `${cmd(obj.cmd)} \`padding\` option must be either a number or an array of numbers with a maximum length of 4. You passed: \`{{arg}}\``,
-      docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`
-    }; },
+    invalid_arg (obj) {
+      return {
+        message: `${cmd(obj.cmd)} must be called with an object. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
+    invalid_capture (obj) {
+      return {
+        message: `${cmd(obj.cmd)} \`capture\` option must be one of the following: \`fullPage\`, \`viewport\`, or \`runner\`. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
+    invalid_boolean (obj) {
+      return {
+        message: `${cmd(obj.cmd)} \`{{option}}\` option must be a boolean. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
+    invalid_blackout (obj) {
+      return {
+        message: `${cmd(obj.cmd)} \`blackout\` option must be an array of strings. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
+    invalid_callback (obj) {
+      return {
+        message: `${cmd(obj.cmd)} \`{{callback}}\` option must be a function. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
+    invalid_clip (obj) {
+      return {
+        message: `${cmd(obj.cmd)} \`clip\` option must be an object with the keys \`{ width, height, x, y }\` and number values. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
+    invalid_height (obj) {
+      return {
+        message: `${cmd('screenshot')} only works with a screenshot area with a height greater than zero.`,
+        docsUrl: 'https://on.cypress.io/screenshot',
+      }
+    },
+    invalid_padding (obj) {
+      return {
+        message: `${cmd(obj.cmd)} \`padding\` option must be either a number or an array of numbers with a maximum length of 4. You passed: \`{{arg}}\``,
+        docsUrl: `https://on.cypress.io/${getScreenshotDocsPath(obj.cmd)}`,
+      }
+    },
     multiple_elements: {
       message: `${cmd('screenshot')} only works for a single element. You attempted to screenshot {{numElements}} elements.`,
-      docsUrl: "https://on.cypress.io/screenshot"
+      docsUrl: 'https://on.cypress.io/screenshot',
     },
     timed_out: {
       message: `${cmd('screenshot')} timed out waiting \`{{timeout}}ms\` to complete.`,
-      docsUrl: "https://on.cypress.io/screenshot"
-    }
+      docsUrl: 'https://on.cypress.io/screenshot',
+    },
   },
 
   select: {
     disabled: {
       message: `${cmd('select')} failed because this element is currently disabled:\n\n\`{{node}}\``,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     invalid_element: {
       message: `${cmd('select')} can only be called on a \`<select>\`. Your subject is a: \`{{node}}\``,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     invalid_multiple: {
       message: `${cmd('select')} was called with an array of arguments but does not have a \`multiple\` attribute set.`,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     multiple_elements: {
       message: `${cmd('select')} can only be called on a single \`<select>\`. Your subject contained {{num}} elements.`,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     multiple_matches: {
       message: `${cmd('select')} matched more than one \`option\` by value or text: \`{{value}}\``,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     no_matches: {
       message: `${cmd('select')} failed because it could not find a single \`<option>\` with value or text matching: \`{{value}}\``,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     option_disabled: {
       message: `${cmd('select')} failed because this \`<option>\` you are trying to select is currently disabled:\n\n\`{{node}}\``,
-      docsUrl: "https://on.cypress.io/select"
+      docsUrl: 'https://on.cypress.io/select',
     },
     optgroup_disabled: {
       message: `${cmd('select')} failed because this \`<option>\` you are trying to select is within an \`<optgroup>\` that is currently disabled:\n\n\`{{node}}\``,
-      docsUrl: "https://on.cypress.io/select"
-    }
+      docsUrl: 'https://on.cypress.io/select',
+    },
   },
 
   selector_playground: {
     defaults_invalid_arg: {
-      message: "`Cypress.SelectorPlayground.defaults()` must be called with an object. You passed: `{{arg}}`",
-      docsUrl: "https://on.cypress.io/selector-playground-api"
+      message: '`Cypress.SelectorPlayground.defaults()` must be called with an object. You passed: `{{arg}}`',
+      docsUrl: 'https://on.cypress.io/selector-playground-api',
     },
     defaults_invalid_priority: {
-      message: "`Cypress.SelectorPlayground.defaults()` called with invalid `selectorPriority` property. It must be an array. You passed: `{{arg}}`",
-      docsUrl: "https://on.cypress.io/selector-playground-api"
+      message: '`Cypress.SelectorPlayground.defaults()` called with invalid `selectorPriority` property. It must be an array. You passed: `{{arg}}`',
+      docsUrl: 'https://on.cypress.io/selector-playground-api',
     },
     defaults_invalid_on_element: {
-      message: "`Cypress.SelectorPlayground.defaults()` called with invalid `onElement` property. It must be a function. You passed: `{{arg}}`",
-      docsUrl: "https://on.cypress.io/selector-playground-api"
-    }
+      message: '`Cypress.SelectorPlayground.defaults()` called with invalid `onElement` property. It must be a function. You passed: `{{arg}}`',
+      docsUrl: 'https://on.cypress.io/selector-playground-api',
+    },
   },
 
   server: {
-    force404_deprecated: "Passing `cy.server({force404: false})` is now the default behavior of `cy.server()`. You can safely remove this option.",
+    force404_deprecated: 'Passing `cy.server({force404: false})` is now the default behavior of `cy.server()`. You can safely remove this option.',
     invalid_argument: {
       message: `${cmd('server')} accepts only an object literal as its argument.`,
-      docsUrl: "https://on.cypress.io/server"
+      docsUrl: 'https://on.cypress.io/server',
     },
     stub_deprecated: {
-      message: "Passing `cy.server({stub: false})` is now deprecated. You can safely remove: `{stub: false}`.",
-      docsUrl: "https://on.cypress.io/deprecated-stub-false-on-{{type}}"
+      message: 'Passing `cy.server({stub: false})` is now deprecated. You can safely remove: `{stub: false}`.',
+      docsUrl: 'https://on.cypress.io/deprecated-stub-false-on-{{type}}',
     },
-    xhrurl_not_set: "`Server.options.xhrUrl` has not been set",
-    unavailable: "The XHR server is unavailable or missing. This should never happen and likely is a bug. Open an issue if you see this message."
+    xhrurl_not_set: '`Server.options.xhrUrl` has not been set',
+    unavailable: 'The XHR server is unavailable or missing. This should never happen and likely is a bug. Open an issue if you see this message.',
   },
 
   setCookie: {
     invalid_arguments: {
       message: `${cmd('setCookie')} must be passed two string arguments for \`name\` and \`value\`.`,
-      docsUrl: "https://on.cypress.io/setcookie"
+      docsUrl: 'https://on.cypress.io/setcookie',
     },
     invalid_value: {
       message: `${cmd('setCookie')} must be passed an RFC-6265-compliant cookie value. You passed:\n\n\`{{value}}\``,
-      docsUrl: "https://on.cypress.io/setcookie"
-    },
-    invalid_samesite: ({ validValues, value }) => ({
-      message: `\
-If a \`sameSite\` value is supplied to ${cmd('setCookie')}, it must be a string from the following list:
-  > ${validValues.join(', ')}
-You passed:
-  > ${format(value)}\
-`,
-      docsUrl: "https://on.cypress.io/setcookie"
-    }),
-    secure_not_set_with_samesite_none: ({ validValues, value }) => ({
-      message: `\
-Only cookies with the \`secure\` flag set to \`true\` can use \`sameSite: '{{value}}'\`.
-
-Pass \`secure: true\` to ${cmd('setCookie')} to set a cookie with \`sameSite: '{{value}}'\`.\
-`,
-      docsUrl: "https://on.cypress.io/setcookie"
-    })
+      docsUrl: 'https://on.cypress.io/setcookie',
+    },
+    invalid_samesite: ({ validValues, value }) => {
+      return {
+        message: stripIndent`\
+          If a \`sameSite\` value is supplied to ${cmd('setCookie')}, it must be a string from the following list:
+            > ${validValues.join(', ')}
+          You passed:
+            > ${format(value)}`,
+        docsUrl: 'https://on.cypress.io/setcookie',
+      }
+    },
+    secure_not_set_with_samesite_none: ({ validValues, value }) => {
+      return {
+        message: stripIndent`\
+          Only cookies with the \`secure\` flag set to \`true\` can use \`sameSite: '{{value}}'\`.
+
+          Pass \`secure: true\` to ${cmd('setCookie')} to set a cookie with \`sameSite: '{{value}}'\`.`,
+        docsUrl: 'https://on.cypress.io/setcookie',
+      }
+    },
   },
 
   should: {
-    chainer_not_found: "The chainer `{{chainer}}` was not found. Could not build assertion.",
-    eventually_deprecated: "The `eventually` assertion chainer has been deprecated. This is now the default behavior so you can safely remove this word and everything should work as before."
+    chainer_not_found: 'The chainer `{{chainer}}` was not found. Could not build assertion.',
+    eventually_deprecated: 'The `eventually` assertion chainer has been deprecated. This is now the default behavior so you can safely remove this word and everything should work as before.',
   },
 
   spread: {
     invalid_type: {
       message: `${cmd('spread')} requires the existing subject be array-like.`,
-      docsUrl: "https://on.cypress.io/spread"
-    }
+      docsUrl: 'https://on.cypress.io/spread',
+    },
   },
 
   subject: {
-    not_dom(obj) {
-      return `\
-${cmd(obj.name)} failed because it requires a valid DOM object.
+    not_dom (obj) {
+      return stripIndent`\
+        ${cmd(obj.name)} failed because it requires a valid DOM object.
 
-The subject received was:
+        The subject received was:
 
-  > \`${obj.subject}\`
+          > \`${obj.subject}\`
 
-The previous command that ran was:
+        The previous command that ran was:
 
-  > ${cmd(obj.previous)}
+          > ${cmd(obj.previous)}
 
-Cypress only considers the \`window\`, \`document\`, or any \`element\` to be valid DOM objects.\
-`;
+        Cypress only considers the \`window\`, \`document\`, or any \`element\` to be valid DOM objects.`
     },
-    not_attached(obj) { return {
-      message: `\
-${cmd(obj.cmd)} failed because this element is detached from the DOM.
+    not_attached (obj) {
+      return {
+        message: stripIndent`\
+          ${cmd(obj.cmd)} failed because this element is detached from the DOM.
 
-\`${obj.node}\`
+          \`${obj.node}\`
 
-Cypress requires elements be attached in the DOM to interact with them.
+          Cypress requires elements be attached in the DOM to interact with them.
 
-The previous command that ran was:
+          The previous command that ran was:
 
-  > ${cmd(obj.prev)}
+            > ${cmd(obj.prev)}
 
-This DOM element likely became detached somewhere between the previous and current command.
+          This DOM element likely became detached somewhere between the previous and current command.
 
-Common situations why this happens:
-  - Your JS framework re-rendered asynchronously
-  - Your app code reacted to an event firing and removed the element
+          Common situations why this happens:
+            - Your JS framework re-rendered asynchronously
+            - Your app code reacted to an event firing and removed the element
 
-You typically need to re-query for the element or add 'guards' which delay Cypress from running new commands.\
-`,
-      docsUrl: "https://on.cypress.io/element-has-detached-from-dom"
-    }; },
-    not_window_or_document(obj) {
-      return `\
-${cmd(obj.name)} failed because it requires the subject be a global \`${obj.type}\` object.
+          You typically need to re-query for the element or add 'guards' which delay Cypress from running new commands.`,
+        docsUrl: 'https://on.cypress.io/element-has-detached-from-dom',
+      }
+    },
+    not_window_or_document (obj) {
+      return stripIndent`\
+        ${cmd(obj.name)} failed because it requires the subject be a global \`${obj.type}\` object.
 
-The subject received was:
+        The subject received was:
 
-  > \`${obj.subject}\`
+          > \`${obj.subject}\`
 
-The previous command that ran was:
+        The previous command that ran was:
 
-  > ${cmd(obj.previous)}\
-`;
+          > ${cmd(obj.previous)}`
     },
-    not_element(obj) {
-      return `\
-${cmd(obj.name)} failed because it requires a DOM element.
+    not_element (obj) {
+      return stripIndent`\
+        ${cmd(obj.name)} failed because it requires a DOM element.
 
-The subject received was:
+        The subject received was:
 
-  > \`${obj.subject}\`
+          > \`${obj.subject}\`
 
-The previous command that ran was:
+        The previous command that ran was:
 
-  > ${cmd(obj.previous)}\
-`;
-    }
+          > ${cmd(obj.previous)}`
+    },
   },
 
   submit: {
     multiple_forms: {
       message: `${cmd('submit')} can only be called on a single \`form\`. Your subject contained {{num}} \`form\` elements.`,
-      docsUrl: "https://on.cypress.io/submit"
+      docsUrl: 'https://on.cypress.io/submit',
     },
     not_on_form: {
       message: `${cmd('submit')} can only be called on a \`<form>\`. Your subject {{word}} a: \`{{node}}\``,
-      docsUrl: "https://on.cypress.io/submit"
-    }
+      docsUrl: 'https://on.cypress.io/submit',
+    },
   },
 
   task: {
-    known_error: `${cmd('task', '\'{{task}}\'')} failed with the following error:
+    known_error: stripIndent`
+      ${cmd('task', '\'{{task}}\'')} failed with the following error:
 
-{{error}}\
-`,
-    failed: `${cmd('task', '\'{{task}}\'')} failed with the following error:
+      {{error}}`,
+    failed: stripIndent`
+      ${cmd('task', '\'{{task}}\'')} failed with the following error:
 
-> {{error}}\
-`,
+      > {{error}}`,
     invalid_argument: {
       message: `${cmd('task')} must be passed a non-empty string as its 1st argument. You passed: \`{{task}}\`.`,
-      docsUrl: "https://on.cypress.io/task"
+      docsUrl: 'https://on.cypress.io/task',
     },
     timed_out: {
       message: `${cmd('task', '\'{{task}}\'')} timed out after waiting \`{{timeout}}ms\`.`,
-      docsUrl: "https://on.cypress.io/task"
+      docsUrl: 'https://on.cypress.io/task',
     },
     server_timed_out: {
-      message: `${cmd('task', '\'{{task}}\'')} timed out after waiting \`{{timeout}}ms\`.
+      message: stripIndent`
+        ${cmd('task', '\'{{task}}\'')} timed out after waiting \`{{timeout}}ms\`.
 
-{{error}}\
-`,
-      docsUrl: "https://on.cypress.io/task"
-    }
+        {{error}}`,
+      docsUrl: 'https://on.cypress.io/task',
+    },
   },
 
   tick: {
     invalid_argument: {
       message: `\`clock.tick()\`/${cmd('tick')} only accepts a number as their argument. You passed: \`{{arg}}\``,
-      docsUrl: "https://on.cypress.io/tick"
+      docsUrl: 'https://on.cypress.io/tick',
     },
     no_clock: {
       message: `${cmd('tick')} cannot be called without first calling ${cmd('clock')}`,
-      docsUrl: "https://on.cypress.io/tick"
-    }
+      docsUrl: 'https://on.cypress.io/tick',
+    },
   },
 
   then: {
-    callback_mixes_sync_and_async: `\
-${cmd('then')} failed because you are mixing up async and sync code.
+    callback_mixes_sync_and_async: stripIndent`\
+      ${cmd('then')} failed because you are mixing up async and sync code.
 
-In your callback function you invoked 1 or more cy commands but then returned a synchronous value.
+      In your callback function you invoked 1 or more cy commands but then returned a synchronous value.
 
-Cypress commands are asynchronous and it doesn't make sense to queue cy commands and yet return a synchronous value.
+      Cypress commands are asynchronous and it doesn't make sense to queue cy commands and yet return a synchronous value.
 
-You likely forgot to properly chain the cy commands using another \`cy.then()\`.
+      You likely forgot to properly chain the cy commands using another \`cy.then()\`.
 
-The value you synchronously returned was: \`{{value}}\`\
-`
+      The value you synchronously returned was: \`{{value}}\``,
   },
 
   trigger: {
     invalid_argument: {
       message: `${cmd('trigger')} must be passed a non-empty string as its 1st argument. You passed: \`{{cmd}}\`.`,
-      docsUrl: "https://on.cypress.io/trigger"
+      docsUrl: 'https://on.cypress.io/trigger',
     },
     multiple_elements: {
       message: `${cmd('trigger')} can only be called on a single element. Your subject contained {{num}} elements.`,
-      docsUrl: "https://on.cypress.io/trigger"
-    }
+      docsUrl: 'https://on.cypress.io/trigger',
+    },
   },
 
   type: {
     empty_string: {
       message: `${cmd('type')} cannot accept an empty string. You need to actually type something.`,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     invalid: {
-      message: `\
-Special character sequence: \`{{chars}}\` is not recognized. Available sequences are: \`{{allChars}}\`
+      message: stripIndent`\
+        Special character sequence: \`{{chars}}\` is not recognized. Available sequences are: \`{{allChars}}\`
 
-If you want to skip parsing special character sequences and type the text exactly as written, pass the option: \`{ parseSpecialCharSequences: false }\`\
-`,
-      docsUrl: "https://on.cypress.io/type"
+        If you want to skip parsing special character sequences and type the text exactly as written, pass the option: \`{ parseSpecialCharSequences: false }\``,
+      docsUrl: 'https://on.cypress.io/type',
     },
     invalid_date: {
       message: `Typing into a \`date\` input with ${cmd('type')} requires a valid date with the format \`yyyy-MM-dd\`. You passed: \`{{chars}}\``,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     invalid_datetime: {
       message: `Typing into a datetime input with ${cmd('type')} requires a valid datetime with the format \`yyyy-MM-ddThh:mm\`, for example \`2017-06-01T08:30\`. You passed: \`{{chars}}\``,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     invalid_month: {
       message: `Typing into a \`month\` input with ${cmd('type')} requires a valid month with the format \`yyyy-MM\`. You passed: \`{{chars}}\``,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     invalid_time: {
       message: `Typing into a \`time\` input with ${cmd('type')} requires a valid time with the format \`HH:mm\`, \`HH:mm:ss\` or \`HH:mm:ss.SSS\`, where \`HH\` is 00-23, \`mm\` is 00-59, \`ss\` is 00-59, and \`SSS\` is 000-999. You passed: \`{{chars}}\``,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     invalid_week: {
       message: `Typing into a \`week\` input with ${cmd('type')} requires a valid week with the format \`yyyy-Www\`, where \`W\` is the literal character \`W\` and \`ww\` is the week number (00-53). You passed: \`{{chars}}\``,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     multiple_elements: {
       message: `${cmd('type')} can only be called on a single element. Your subject contained {{num}} elements.`,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     not_actionable_textlike: {
-      message: `\
-${cmd('type')} failed because it targeted a disabled element.
+      message: stripIndent`\
+        ${cmd('type')} failed because it targeted a disabled element.
 
-The element typed into was:
+        The element typed into was:
 
-  > {{node}}
+          > {{node}}
 
-Ensure the element does not have an attribute named \`disabled\` before typing into it.\
-`,
-      docsUrl: "https://on.cypress.io/type"
+        Ensure the element does not have an attribute named \`disabled\` before typing into it.`,
+      docsUrl: 'https://on.cypress.io/type',
     },
     not_on_typeable_element: {
-      message: `\
-${cmd('type')} failed because it requires a valid typeable element.
-
-The element typed into was:
-
-  > \`{{node}}\`
-
-  A typeable element matches one of the following selectors:
-  \`a[href]\`
-  \`area[href]\`
-  \`input\`
-  \`select\`
-  \`textarea\`
-  \`button\`
-  \`iframe\`
-  \`[tabindex]\`
-  \`[contenteditable]\`\
-`,
-      docsUrl: "https://on.cypress.io/type"
+      message: stripIndent`\
+        ${cmd('type')} failed because it requires a valid typeable element.
+
+        The element typed into was:
+
+          > \`{{node}}\`
+
+          A typeable element matches one of the following selectors:
+          \`a[href]\`
+          \`area[href]\`
+          \`input\`
+          \`select\`
+          \`textarea\`
+          \`button\`
+          \`iframe\`
+          \`[tabindex]\`
+          \`[contenteditable]\``,
+      docsUrl: 'https://on.cypress.io/type',
     },
     readonly: {
       message: `${cmd('type')} cannot type into an element with a \`readonly\` attribute. The element typed into was: \`{{node}}\``,
-      docsUrl: "https://on.cypress.io/type"
+      docsUrl: 'https://on.cypress.io/type',
     },
     tab: {
-      message: "`{tab}` isn't a supported character sequence.",
-      docsUrl: "https://on.cypress.io/type"
+      message: '`{tab}` isn\'t a supported character sequence.',
+      docsUrl: 'https://on.cypress.io/type',
     },
     wrong_type: {
       message: `${cmd('type')} can only accept a string or number. You passed in: \`{{chars}}\``,
-      docsUrl: "https://on.cypress.io/type"
-    }
+      docsUrl: 'https://on.cypress.io/type',
+    },
   },
 
   uncaught: {
     cross_origin_script: {
-      message: `\
-Script error.
+      message: stripIndent`\
+        Script error.
 
-Cypress detected that an uncaught error was thrown from a cross origin script.
+        Cypress detected that an uncaught error was thrown from a cross origin script.
 
-We cannot provide you the stack trace, line number, or file where this error occurred.
+        We cannot provide you the stack trace, line number, or file where this error occurred.
 
-Check your Developer Tools Console for the actual error - it should be printed there.
+        Check your Developer Tools Console for the actual error - it should be printed there.
 
-It's possible to enable debugging these scripts by adding the \`crossorigin\` attribute and setting a CORS header.\
-`,
-      docsUrl: "https://on.cypress.io/cross-origin-script-error"
+        It's possible to enable debugging these scripts by adding the \`crossorigin\` attribute and setting a CORS header.`,
+      docsUrl: 'https://on.cypress.io/cross-origin-script-error',
     },
-    error_in_hook(obj) {
-      let t;
-      let msg = `Because this error occurred during a \`${obj.hookName}\` hook we are skipping `;
+    error_in_hook (obj) {
+      let msg = `Because this error occurred during a \`${obj.hookName}\` hook we are skipping `
 
-      if ((t = obj.parentTitle)) {
-        msg += `the remaining tests in the current suite: \`${_.truncate(t, 20)}\``;
+      const t = obj.parentTitle
+
+      if (t) {
+        msg += `the remaining tests in the current suite: \`${_.truncate(t, 20)}\``
       } else {
-        msg += "all of the remaining tests.";
+        msg += 'all of the remaining tests.'
       }
 
-      return msg;
+      return msg
     },
-    error(obj) {
-      const {message, source, lineno} = obj;
+    error (obj) {
+      const { message, source, lineno } = obj
 
-      return message + (source && lineno ? ` (${source}:${lineno})` : "");
+      return message + (source && lineno ? ` (${source}:${lineno})` : '')
     },
     fromApp: {
-      message: `\
-The following error originated from your application code, not from Cypress.
+      message: stripIndent`\
+        The following error originated from your application code, not from Cypress.
 
-  > {{errMsg}}
+          > {{errMsg}}
 
-When Cypress detects uncaught errors originating from your application it will automatically fail the current test.
+        When Cypress detects uncaught errors originating from your application it will automatically fail the current test.
 
-This behavior is configurable, and you can choose to turn this off by listening to the \`uncaught:exception\` event.\
-`,
-      docsUrl: "https://on.cypress.io/uncaught-exception-from-application"
+        This behavior is configurable, and you can choose to turn this off by listening to the \`uncaught:exception\` event.`,
+      docsUrl: 'https://on.cypress.io/uncaught-exception-from-application',
     },
     fromSpec: {
-      message: `\
-The following error originated from your test code, not from Cypress.
+      message: stripIndent`\
+        The following error originated from your test code, not from Cypress.
 
-  > {{errMsg}}
+          > {{errMsg}}
 
-When Cypress detects uncaught errors originating from your test code it will automatically fail the current test.\
-`
-    }
+        When Cypress detects uncaught errors originating from your test code it will automatically fail the current test.`,
+    },
   },
 
   viewport: {
     bad_args: {
       message: `${cmd('viewport')} can only accept a string preset or a \`width\` and \`height\` as numbers.`,
-      docsUrl: "https://on.cypress.io/viewport"
+      docsUrl: 'https://on.cypress.io/viewport',
     },
     dimensions_out_of_range: {
       message: `${cmd('viewport')} \`width\` and \`height\` must be at least 0px.`,
-      docsUrl: "https://on.cypress.io/viewport"
+      docsUrl: 'https://on.cypress.io/viewport',
     },
     empty_string: {
       message: `${cmd('viewport')} cannot be passed an empty string.`,
-      docsUrl: "https://on.cypress.io/viewport"
+      docsUrl: 'https://on.cypress.io/viewport',
     },
     invalid_orientation: {
       message: `${cmd('viewport')} can only accept \`{{all}}\` as valid orientations. Your orientation was: \`{{orientation}}\``,
-      docsUrl: "https://on.cypress.io/viewport"
+      docsUrl: 'https://on.cypress.io/viewport',
     },
     missing_preset: {
       message: `${cmd('viewport')} could not find a preset for: \`{{preset}}\`. Available presets are: {{presets}}`,
-      docsUrl: "https://on.cypress.io/viewport"
-    }
+      docsUrl: 'https://on.cypress.io/viewport',
+    },
   },
 
   visit: {
-    body_circular({ path }) { return {
-      message: `\
-The \`body\` parameter supplied to ${cmd('visit')} contained a circular reference at the path "${path.join(".")}".
-
-\`body\` can only be a string or an object with no circular references.\
-`,
-      docsUrl: "https://on.cypress.io/visit"
-    }; },
-    status_code_flags_invalid: `\
-
-These options are incompatible with each other.
-
- - To retry on non-2xx status codes, pass { failOnStatusCode: true, retryOnStatusCodeFailure: true }.
- - To not retry on non-2xx status codes, pass { failOnStatusCode: true, retryOnStatusCodeFailure: true }.
- - To fail on non-2xx status codes without retrying (the default behavior), pass { failOnStatusCode: true, retryOnStatusCodeFailure: false }\
-`,
+    body_circular ({ path }) {
+      return {
+        message: stripIndent`\
+          The \`body\` parameter supplied to ${cmd('visit')} contained a circular reference at the path "${path.join('.')}".
+
+          \`body\` can only be a string or an object with no circular references.`,
+        docsUrl: 'https://on.cypress.io/visit',
+      }
+    },
+    status_code_flags_invalid: stripIndent`\
+      These options are incompatible with each other.
+
+       - To retry on non-2xx status codes, pass { failOnStatusCode: true, retryOnStatusCodeFailure: true }.
+       - To not retry on non-2xx status codes, pass { failOnStatusCode: true, retryOnStatusCodeFailure: true }.
+       - To fail on non-2xx status codes without retrying (the default behavior), pass { failOnStatusCode: true, retryOnStatusCodeFailure: false }`,
     invalid_1st_arg: {
       message: `${cmd('visit')} must be called with a \`url\` or an \`options\` object containing a \`url\` as its 1st argument`,
-      docsUrl: "https://on.cypress.io/visit"
+      docsUrl: 'https://on.cypress.io/visit',
     },
     invalid_method: {
       message: `${cmd('visit')} was called with an invalid method: \`{{method}}\`. Method can only be \`GET\` or \`POST\`.`,
-      docsUrl: "https://on.cypress.io/visit"
+      docsUrl: 'https://on.cypress.io/visit',
     },
     invalid_headers: {
       message: `${cmd('visit')} requires the \`headers\` option to be an object.`,
-      docsUrl: "https://on.cypress.io/visit"
+      docsUrl: 'https://on.cypress.io/visit',
     },
     invalid_qs: {
       message: `${cmd('visit')} requires the \`qs\` option to be an object, but received: \`{{qs}}\``,
-      docsUrl: "https://on.cypress.io/visit"
+      docsUrl: 'https://on.cypress.io/visit',
     },
     no_duplicate_url: {
-      message: `\
-${cmd('visit')} must be called with only one \`url\`. You specified two urls:
-\`url\` from the \`options\` object: {{optionsUrl}}
-\`url\` from the \`url\` parameter: {{url}}\
-`,
-      docsUrl: "https://on.cypress.io/visit"
+      message: stripIndent`\
+        ${cmd('visit')} must be called with only one \`url\`. You specified two urls:
+        \`url\` from the \`options\` object: {{optionsUrl}}
+        \`url\` from the \`url\` parameter: {{url}}`,
+      docsUrl: 'https://on.cypress.io/visit',
     },
     cannot_visit_different_origin: {
-      message: `\
-${cmd('visit')} failed because you are attempting to visit a URL that is of a different origin.
+      message: stripIndent`\
+        ${cmd('visit')} failed because you are attempting to visit a URL that is of a different origin.
 
-The new URL is considered a different origin because the following parts of the URL are different:
+        The new URL is considered a different origin because the following parts of the URL are different:
 
-  > {{differences}}
+          > {{differences}}
 
-You may only ${cmd('visit')} same-origin URLs within a single test.
+        You may only ${cmd('visit')} same-origin URLs within a single test.
 
-The previous URL you visited was:
+        The previous URL you visited was:
 
-  > '{{previousUrl}}'
+          > '{{previousUrl}}'
 
-You're attempting to visit this URL:
+        You're attempting to visit this URL:
 
-  > '{{attemptedUrl}}'
+          > '{{attemptedUrl}}'
 
-You may need to restructure some of your test code to avoid this problem.\
-`,
-      docsUrl: "https://on.cypress.io/cannot-visit-different-origin-domain"
+        You may need to restructure some of your test code to avoid this problem.`,
+      docsUrl: 'https://on.cypress.io/cannot-visit-different-origin-domain',
     },
-    loading_network_failed: `\
-${cmd('visit')} failed trying to load:
+    loading_network_failed: stripIndent`\
+      ${cmd('visit')} failed trying to load:
 
-{{url}}
+      {{url}}
 
-We attempted to make an http request to this URL but the request failed without a response.
+      We attempted to make an http request to this URL but the request failed without a response.
 
-We received this error at the network level:
+      We received this error at the network level:
 
-  > {{error}}
+        > {{error}}
 
-Common situations why this would fail:
-  - you don't have internet access
-  - you forgot to run / boot your web server
-  - your web server isn't accessible
-  - you have weird network configuration settings on your computer\
-`,
-    loading_file_failed(obj) {
-      return `\
-${cmd('visit')} failed trying to load:
+      Common situations why this would fail:
+        - you don't have internet access
+        - you forgot to run / boot your web server
+        - your web server isn't accessible
+        - you have weird network configuration settings on your computer`,
+    loading_file_failed (obj) {
+      return stripIndent`
+        ${cmd('visit')} failed trying to load:
 
-${obj.url}
+        ${obj.url}
 
-We failed looking for this file at the path:
+        We failed looking for this file at the path:
 
-${obj.path}
+        ${obj.path}
 
-The internal Cypress web server responded with:
+        The internal Cypress web server responded with:
 
-  > ${obj.status}: ${obj.statusText}
+          > ${obj.status}: ${obj.statusText}
 
-${getRedirects(obj, "We were redirected")}\
-`;
+        ${getRedirects(obj, 'We were redirected', 8)}`
     },
-    loading_http_failed(obj) {
-      return `\
-${cmd('visit')} failed trying to load:
+    loading_http_failed (obj) {
+      return stripIndent`\
+        ${cmd('visit')} failed trying to load:
 
-${obj.url}
+        ${obj.url}
 
-The response we received from your web server was:
+        The response we received from your web server was:
 
-  > ${obj.status}: ${obj.statusText}
+          > ${obj.status}: ${obj.statusText}
 
-This was considered a failure because the status code was not \`2xx\`.
+        This was considered a failure because the status code was not \`2xx\`.
 
-${getRedirects(obj, "This http request was redirected")}
+        ${getRedirects(obj, 'This http request was redirected', 8)}
 
-If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`\
-`;
+        If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\``
     },
-    loading_invalid_content_type(obj) {
-      const phrase = obj.path ? "this local file" : "your web server";
+    loading_invalid_content_type (obj) {
+      const phrase = obj.path ? 'this local file' : 'your web server'
 
-      return `\
-${cmd('visit')} failed trying to load:
+      return stripIndent`\
+        ${cmd('visit')} failed trying to load:
 
-${obj.url}
+        ${obj.url}
 
-The \`content-type\` of the response we received from ${phrase} was:
+        The \`content-type\` of the response we received from ${phrase} was:
 
-  > \`${obj.contentType}\`
+          > \`${obj.contentType}\`
 
-This was considered a failure because responses must have \`content-type: 'text/html'\`
+        This was considered a failure because responses must have \`content-type: 'text/html'\`
 
-However, you can likely use ${cmd('request')} instead of ${cmd('visit')}.
+        However, you can likely use ${cmd('request')} instead of ${cmd('visit')}.
 
-${cmd('request')} will automatically get and set cookies and enable you to parse responses.\
-`;
+        ${cmd('request')} will automatically get and set cookies and enable you to parse responses.`
     },
 
     specify_file_by_relative_path: {
-      message: `\
-${cmd('visit')} failed because the 'file://...' protocol is not supported by Cypress.
+      message: stripIndent`\
+        ${cmd('visit')} failed because the 'file://...' protocol is not supported by Cypress.
 
-To visit a local file, you can pass in the relative path to the file from the \`projectRoot\` (Note: if the configuration value \`baseUrl\` is set, the supplied path will be resolved from the \`baseUrl\` instead of \`projectRoot\`)\
-`,
-      docsUrl: ["https://docs.cypress.io/api/commands/visit.html", "/https://docs.cypress.io/api/cypress-api/config.html"]
-    }
+        To visit a local file, you can pass in the relative path to the file from the \`projectRoot\` (Note: if the configuration value \`baseUrl\` is set, the supplied path will be resolved from the \`baseUrl\` instead of \`projectRoot\`)`,
+      docsUrl: ['https://docs.cypress.io/api/commands/visit.html', '/https://docs.cypress.io/api/cypress-api/config.html'],
+    },
   },
 
   wait: {
     alias_invalid: {
-      message: "`{{prop}}` is not a valid alias property. Are you trying to ask for the first request? If so write `@{{str}}.request`",
-      docsUrl: "https://on.cypress.io/wait"
+      message: '`{{prop}}` is not a valid alias property. Are you trying to ask for the first request? If so write `@{{str}}.request`',
+      docsUrl: 'https://on.cypress.io/wait',
     },
     fn_deprecated: {
       message: `${cmd('wait', 'fn')} has been deprecated. Change this command to be ${cmd('should', 'fn')}.`,
-      docsUrl: "https://on.cypress.io/wait"
+      docsUrl: 'https://on.cypress.io/wait',
     },
     invalid_1st_arg: {
       message: `${cmd('wait')} only accepts a number, an alias of a route, or an array of aliases of routes. You passed: \`{{arg}}\``,
-      docsUrl: "https://on.cypress.io/wait"
+      docsUrl: 'https://on.cypress.io/wait',
     },
     invalid_alias: {
       message: `${cmd('wait')} only accepts aliases for routes.\nThe alias: \`{{alias}}\` did not match a route.`,
-      docsUrl: "https://on.cypress.io/wait"
+      docsUrl: 'https://on.cypress.io/wait',
     },
     invalid_arguments: {
       message: `${cmd('wait')} was passed invalid arguments. You cannot pass multiple strings. If you're trying to wait for multiple routes, use an array.`,
-      docsUrl: "https://on.cypress.io/wait"
+      docsUrl: 'https://on.cypress.io/wait',
     },
     timed_out: {
       message: `${cmd('wait')} timed out waiting \`{{timeout}}ms\` for the {{num}} {{type}} to the route: \`{{alias}}\`. No {{type}} ever occurred.`,
-      docsUrl: "https://on.cypress.io/wait"
-    }
+      docsUrl: 'https://on.cypress.io/wait',
+    },
   },
 
   window: {
-    iframe_doc_undefined: "The remote iframe's document is `undefined`",
-    iframe_undefined: "The remote iframe is `undefined`"
+    iframe_doc_undefined: 'The remote iframe\'s document is `undefined`',
+    iframe_undefined: 'The remote iframe is `undefined`',
   },
 
   within: {
     invalid_argument: {
       message: `${cmd('within')} must be called with a function.`,
-      docsUrl: "https://on.cypress.io/within"
-    }
+      docsUrl: 'https://on.cypress.io/within',
+    },
   },
 
   xhr: {
-    aborted: "This XHR was aborted by your code -- check this stack trace below.",
-    missing: "`XMLHttpRequest#xhr` is missing.",
-    network_error: "The network request for this XHR could not be made. Check your console for the reason.",
-    requestjson_deprecated: "`requestJSON` is now deprecated and will be removed in the next version. Update this to `requestBody` or `request.body`.",
-    responsejson_deprecated: "`responseJSON` is now deprecated and will be removed in the next version. Update this to `responseBody` or `response.body`."
-  }
-};
+    aborted: 'This XHR was aborted by your code -- check this stack trace below.',
+    missing: '`XMLHttpRequest#xhr` is missing.',
+    network_error: 'The network request for this XHR could not be made. Check your console for the reason.',
+    requestjson_deprecated: '`requestJSON` is now deprecated and will be removed in the next version. Update this to `requestBody` or `request.body`.',
+    responsejson_deprecated: '`responseJSON` is now deprecated and will be removed in the next version. Update this to `responseBody` or `response.body`.',
+  },
+}
diff --git a/packages/driver/test/cypress/integration/commands/actions/click_spec.js b/packages/driver/test/cypress/integration/commands/actions/click_spec.js
index 5d3c873e1198..e206c1df3f19 100644
--- a/packages/driver/test/cypress/integration/commands/actions/click_spec.js
+++ b/packages/driver/test/cypress/integration/commands/actions/click_spec.js
@@ -4380,7 +4380,7 @@ describe('mouse state', () => {
       })
       .then(($iframe) => {
         // cypress does not wrap this as a DOM element (does not wrap in jquery)
-        return cy.wrap($iframe.first().contents().find('body'))
+        cy.wrap($iframe.first().contents().find('body'))
       })
       .within(() => {
         cy.get('a#hashchange')
diff --git a/packages/driver/test/cypress/integration/commands/assertions_spec.js b/packages/driver/test/cypress/integration/commands/assertions_spec.js
index 3d69391bf89b..f033d9560699 100644
--- a/packages/driver/test/cypress/integration/commands/assertions_spec.js
+++ b/packages/driver/test/cypress/integration/commands/assertions_spec.js
@@ -123,7 +123,7 @@ describe('src/cy/commands/assertions', () => {
         }
         , 100)
 
-        return cy.wrap(obj)
+        cy.wrap(obj)
       }).should('deep.eq', { foo: 'baz' })
     })
 
diff --git a/packages/driver/test/cypress/integration/commands/misc_spec.js b/packages/driver/test/cypress/integration/commands/misc_spec.js
index 8d2c2da6adf8..0d078b624997 100644
--- a/packages/driver/test/cypress/integration/commands/misc_spec.js
+++ b/packages/driver/test/cypress/integration/commands/misc_spec.js
@@ -1,236 +1,273 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const $ = Cypress.$.bind(Cypress);
-const {
-  _
-} = Cypress;
-
-const $dom = require("../../../../src/dom");
-
-describe("src/cy/commands/misc", function() {
-  before(() => cy
-    .visit("/fixtures/jquery.html")
-    .then(function(win) {
-      return this.body = win.document.body.outerHTML;
-  }));
-
-  beforeEach(function() {
-    const doc = cy.state("document");
-
-    return $(doc.body).empty().html(this.body);
-  });
-
-  context("#end", () => it("nulls out the subject", () => cy.noop({}).end().then(subject => expect(subject).to.be.null)));
-
-  context("#log", function() {
-    it("nulls out the subject", () => cy.wrap({}).log("foo").then(subject => expect(subject).to.be.null));
-
-    return describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
-
-        return null;
-      });
-
-      it("logs immediately", function(done) {
-        cy.on("log:added", (attrs, log) => {
-          cy.removeAllListeners("log:added");
-
-          expect(log.get("message")).to.eq("foo, {foo: bar}");
-          expect(log.get("name")).to.eq("log");
-          expect(log.get("end")).to.be.true;
-          return done();
-        });
-
-        return cy.log("foo", {foo: "bar"}).then(() => {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("ended")).to.be.true;
-          expect(lastLog.get("snapshots").length).to.eq(1);
-          return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-        });
-      });
-
-      return it("consoleProps", () => cy.log("foobarbaz", [{}]).then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "log",
-          args: [{}],
-          message: "foobarbaz"
-        });
-      }));
-    });
-  });
-
-  return context("#wrap", function() {
-    beforeEach(function() {
-      this.remoteWindow = cy.state("window");
-
-      return delete this.remoteWindow.$.fn.foo;
-    });
-
-    it("sets the subject to the first argument", () => cy.wrap({}).then(subject => expect(subject).to.deep.eq({})));
-
-    //# https://github.com/cypress-io/cypress/issues/3241
-    it("cy.wrap(undefined) should retry", function() {
-      const stub = cy.stub();
-
-      cy.wrap().should(function() {
-        stub();
-        return expect(stub).to.be.calledTwice;
-      });
-
-      return cy.wrap(undefined).should(function() {
-        stub();
-        return expect(stub.callCount).to.eq(4);
-      });
-    });
-
-    it("can wrap jquery objects and continue to chain", function() {
-      this.remoteWindow.$.fn.foo = "foo";
+const $ = Cypress.$.bind(Cypress)
+const { _ } = Cypress
+
+const $dom = require('../../../../src/dom')
+
+describe('src/cy/commands/misc', () => {
+  before(() => {
+    cy
+    .visit('/fixtures/jquery.html')
+    .then(function (win) {
+      this.body = win.document.body.outerHTML
+    })
+  })
+
+  beforeEach(function () {
+    const doc = cy.state('document')
+
+    $(doc.body).empty().html(this.body)
+  })
+
+  context('#end', () => {
+    it('nulls out the subject', () => {
+      cy.noop({}).end().then((subject) => {
+        expect(subject).to.be.null
+      })
+    })
+  })
+
+  context('#log', () => {
+    it('nulls out the subject', () => {
+      cy.wrap({}).log('foo').then((subject) => {
+        expect(subject).to.be.null
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('logs immediately', function (done) {
+        cy.on('log:added', (attrs, log) => {
+          cy.removeAllListeners('log:added')
+
+          expect(log.get('message')).to.eq('foo, {foo: bar}')
+          expect(log.get('name')).to.eq('log')
+          expect(log.get('end')).to.be.true
+
+          done()
+        })
+
+        cy.log('foo', { foo: 'bar' }).then(() => {
+          const { lastLog } = this
+
+          expect(lastLog.get('ended')).to.be.true
+          expect(lastLog.get('snapshots').length).to.eq(1)
+
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
+
+      it('consoleProps', () => {
+        return cy.log('foobarbaz', [{}]).then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'log',
+            args: [{}],
+            message: 'foobarbaz',
+          })
+        })
+      })
+    })
+  })
+
+  context('#wrap', () => {
+    beforeEach(function () {
+      this.remoteWindow = cy.state('window')
+
+      delete this.remoteWindow.$.fn.foo
+    })
+
+    it('sets the subject to the first argument', () => {
+      cy.wrap({}).then((subject) => {
+        expect(subject).to.deep.eq({})
+      })
+    })
+
+    // https://github.com/cypress-io/cypress/issues/3241
+    it('cy.wrap(undefined) should retry', () => {
+      const stub = cy.stub()
+
+      cy.wrap().should(() => {
+        stub()
+
+        expect(stub).to.be.calledTwice
+      })
+
+      cy.wrap(undefined).should(() => {
+        stub()
+
+        expect(stub.callCount).to.eq(4)
+      })
+    })
+
+    it('can wrap jquery objects and continue to chain', function () {
+      this.remoteWindow.$.fn.foo = 'foo'
 
       const append = () => {
-        return setTimeout(() => {
-          return $("<li class='appended'>appended</li>").appendTo(cy.$$("#list"));
-        }
-        , 50);
-      };
+        setTimeout(() => {
+          $('<li class=\'appended\'>appended</li>').appendTo(cy.$$('#list'))
+        }, 50)
+      }
 
-      cy.on("command:retry", _.after(2, _.once(append)));
+      cy.on('command:retry', _.after(2, _.once(append)))
 
-      return cy.get("#list").then($ul => cy
+      cy.get('#list').then(($ul) => {
+        cy
         // ensure that assertions are based on the real subject
         // and not the cy subject - therefore foo should be defined
-        .wrap($ul).should("have.property", "foo")
+        .wrap($ul).should('have.property', 'foo')
 
         // then re-wrap $ul and ensure that the subject passed
         // downstream is the cypress instance
         .wrap($ul)
-        .find("li.appended")
-        .then($li => //# must use explicit non cy.should
-      //# else this test will always pass
-      expect($li.length).to.eq(1)));
-    });
-
-    //# TODO: fix this test in 4.0 when we refactor validating subjects
-    it.skip("throws a good error when wrapping mixed types: element + string", () => cy.get("button").then(function($btn) {
-      const btn = $btn.get(0);
-
-      return cy.wrap([btn, "asdf"]).click();
-    }));
-
-    it("can wrap an array of DOM elements and pass command validation", () => cy.get("button").then(function($btn) {
-      const btn = $btn.get(0);
-
-      cy.wrap([btn]).click().then($btn => expect($dom.isJquery($btn)).to.be.true);
-
-      return cy.wrap([btn, btn]).click({ multiple: true }).then($btns => expect($dom.isJquery($btns)).to.be.true);
-    }));
-
-    it("can wrap an array of window without it being altered", () => cy.window().then(win => cy.wrap([win]).then(function(arr) {
-      expect(arr).to.be.an('array');
-      return expect(Array.isArray(arr)).to.be.true;
-    })));
-
-    it("can wrap an array of document without it being altered", () => cy.document().then(doc => cy.wrap([doc]).then(function(arr) {
-      expect(arr).to.be.an('array');
-      expect(Array.isArray(arr)).to.be.true;
-      return expect(arr[0]).to.eq(doc);
-    })));
-
-    //# https://github.com/cypress-io/cypress/issues/2927
-    it("can properly handle objects with 'jquery' functions as properties", () => //# the root issue here has to do with the fact that window.jquery points
-    //# to the jquery constructor, but not an actual jquery instance and
-    //# we need to account for that...
-    cy.window().then(function(win) {
-      win.jquery = function() {};
-
-      return win;
-    }));
-
-    describe("errors", function() {
-      it("throws when wrapping an array of windows", function(done) {
-        cy.on("fail", err => {
-          expect(err.message).to.include("`cy.scrollTo()` failed because it requires a DOM element.");
-          expect(err.message).to.include("[<window>]");
-          expect(err.message).to.include("All 2 subject validations failed on this subject.");
-          return done();
-        });
-
-        return cy.window().then(win => cy.wrap([win]).scrollTo("bottom"));
-      });
-
-      return it("throws when wrapping an array of documents", function(done) {
-        cy.on("fail", err => {
-          expect(err.message).to.include("`cy.screenshot()` failed because it requires a DOM element.");
-          expect(err.message).to.include("[<document>]");
-          expect(err.message).to.include("All 3 subject validations failed on this subject.");
-          return done();
-        });
-
-        return cy.document().then(doc => cy.wrap([doc]).screenshot());
-      });
-    });
-
-    return describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
-
-        return null;
-      });
-
-      it("logs immediately", function(done) {
-        cy.on("log:added", (attrs, log) => {
-          cy.removeAllListeners("log:added");
-
-          expect(log.get("message")).to.eq("{}");
-          expect(log.get("name")).to.eq("wrap");
-          expect(log.get("end")).not.to.be.ok;
-          return done();
-        });
-
-        return cy.wrap({}).then(() => {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("ended")).to.be.true;
-          expect(lastLog.get("snapshots").length).to.eq(1);
-          return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-        });
-      });
-
-      return it("stringifies DOM elements and sets $el", function() {
-        const body = $("body");
-
-        return cy.wrap(body).then(function($el) {
-          const {
-            lastLog
-          } = this;
-
-          //# internally we store the real remote jquery
-          //# instance instead of the cypress one
-          expect(lastLog.get("$el")).not.to.eq($el);
-
-          //# but make sure they are the same DOM object
-          expect(lastLog.get("$el").get(0)).to.eq($el.get(0));
-          return expect(lastLog.get("message")).to.eq("<body>");
-        });
-      });
-    });
-  });
-});
+        .find('li.appended')
+        .then(($li) => {
+          // must use explicit non cy.should
+          // else this test will always pass
+          expect($li.length).to.eq(1)
+        })
+      })
+    })
+
+    // TODO: fix this test in 4.0 when we refactor validating subjects
+    it.skip('throws a good error when wrapping mixed types: element + string', () => {
+      cy.get('button').then(($btn) => {
+        const btn = $btn.get(0)
+
+        cy.wrap([btn, 'asdf']).click()
+      })
+    })
+
+    it('can wrap an array of DOM elements and pass command validation', () => {
+      cy.get('button').then(($btn) => {
+        const btn = $btn.get(0)
+
+        cy.wrap([btn]).click().then(($btn) => {
+          expect($dom.isJquery($btn)).to.be.true
+        })
+
+        cy.wrap([btn, btn]).click({ multiple: true }).then(($btns) => {
+          expect($dom.isJquery($btns)).to.be.true
+        })
+      })
+    })
+
+    it('can wrap an array of window without it being altered', () => {
+      cy.window().then((win) => {
+        cy.wrap([win]).then((arr) => {
+          expect(arr).to.be.an('array')
+          expect(Array.isArray(arr)).to.be.true
+        })
+      })
+    })
+
+    it('can wrap an array of document without it being altered', () => {
+      cy.document().then((doc) => {
+        cy.wrap([doc]).then((arr) => {
+          expect(arr).to.be.an('array')
+          expect(Array.isArray(arr)).to.be.true
+          expect(arr[0]).to.eq(doc)
+        })
+      })
+    })
+
+    // https://github.com/cypress-io/cypress/issues/2927
+    it('can properly handle objects with \'jquery\' functions as properties', () => {
+      // the root issue here has to do with the fact that window.jquery points
+      // to the jquery constructor, but not an actual jquery instance and
+      // we need to account for that...
+      cy.window().then((win) => {
+        win.jquery = function () {}
+
+        return win
+      })
+    })
+
+    describe('errors', () => {
+      it('throws when wrapping an array of windows', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.scrollTo()` failed because it requires a DOM element.')
+          expect(err.message).to.include('[<window>]')
+          expect(err.message).to.include('All 2 subject validations failed on this subject.')
+
+          done()
+        })
+
+        cy.window().then((win) => {
+          cy.wrap([win]).scrollTo('bottom')
+        })
+      })
+
+      it('throws when wrapping an array of documents', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.screenshot()` failed because it requires a DOM element.')
+          expect(err.message).to.include('[<document>]')
+          expect(err.message).to.include('All 3 subject validations failed on this subject.')
+
+          done()
+        })
+
+        cy.document().then((doc) => {
+          cy.wrap([doc]).screenshot()
+        })
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('logs immediately', function (done) {
+        cy.on('log:added', (attrs, log) => {
+          cy.removeAllListeners('log:added')
+
+          expect(log.get('message')).to.eq('{}')
+          expect(log.get('name')).to.eq('wrap')
+          expect(log.get('end')).not.to.be.ok
+
+          done()
+        })
+
+        cy.wrap({}).then(() => {
+          const { lastLog } = this
+
+          expect(lastLog.get('ended')).to.be.true
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
+
+      it('stringifies DOM elements and sets $el', () => {
+        const body = $('body')
+
+        cy.wrap(body).then(function ($el) {
+          const { lastLog } = this
+
+          // internally we store the real remote jquery
+          // instance instead of the cypress one
+          expect(lastLog.get('$el')).not.to.eq($el)
+
+          // but make sure they are the same DOM object
+          expect(lastLog.get('$el').get(0)).to.eq($el.get(0))
+          expect(lastLog.get('message')).to.eq('<body>')
+        })
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/navigation_spec.js b/packages/driver/test/cypress/integration/commands/navigation_spec.js
index 8b0ca056cc6c..66ad5c0bd231 100644
--- a/packages/driver/test/cypress/integration/commands/navigation_spec.js
+++ b/packages/driver/test/cypress/integration/commands/navigation_spec.js
@@ -1,2459 +1,2621 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const $ = Cypress.$.bind(Cypress);
-const { _, Promise } = Cypress;
+const { stripIndent } = require('common-tags')
+const $ = Cypress.$.bind(Cypress)
+const { _, Promise } = Cypress
+
+const Cookie = require('js-cookie')
+
+describe('src/cy/commands/navigation', () => {
+  context('#reload', () => {
+    before(() => {
+      cy
+      .visit('/fixtures/generic.html')
+      .then(function (win) {
+        this.body = win.document.body.outerHTML
+      })
+    })
 
-const Cookie = require("js-cookie");
+    beforeEach(function () {
+      const doc = cy.state('document')
 
-describe("src/cy/commands/navigation", function() {
-  context("#reload", function() {
-    before(() => cy
-      .visit("/fixtures/generic.html")
-      .then(function(win) {
-        return this.body = win.document.body.outerHTML;
-    }));
+      this.win = cy.state('window')
 
-    beforeEach(function() {
-      const doc = cy.state("document");
-      this.win = cy.state("window");
+      $(doc.body).empty().html(this.body)
+    })
 
-      return $(doc.body).empty().html(this.body);
-    });
+    afterEach(function () {
+      cy.state('window', this.win)
+    })
 
-    afterEach(function() {
-      return cy.state("window", this.win);
-    });
+    it('calls into window.location.reload', () => {
+      const locReload = cy.spy(Cypress.utils, 'locReload')
 
-    it("calls into window.location.reload", function() {
-      const locReload = cy.spy(Cypress.utils, "locReload");
+      cy.reload().then(() => {
+        expect(locReload).to.be.calledWith(false)
+      })
+    })
 
-      return cy.reload().then(() => expect(locReload).to.be.calledWith(false));
-    });
+    it('can pass forceReload', () => {
+      const locReload = cy.spy(Cypress.utils, 'locReload')
 
-    it("can pass forceReload", function() {
-      const locReload = cy.spy(Cypress.utils, "locReload");
+      cy.reload(true).then(() => {
+        expect(locReload).to.be.calledWith(true)
+      })
+    })
 
-      return cy.reload(true).then(() => expect(locReload).to.be.calledWith(true));
-    });
+    it('can pass forceReload + options', () => {
+      const locReload = cy.spy(Cypress.utils, 'locReload')
 
-    it("can pass forceReload + options", function() {
-      const locReload = cy.spy(Cypress.utils, "locReload");
+      cy.reload(true, {}).then(() => {
+        expect(locReload).to.be.calledWith(true)
+      })
+    })
 
-      return cy.reload(true, {}).then(() => expect(locReload).to.be.calledWith(true));
-    });
+    it('can pass just options', () => {
+      const locReload = cy.spy(Cypress.utils, 'locReload')
 
-    it("can pass just options", function() {
-      const locReload = cy.spy(Cypress.utils, "locReload");
+      cy.reload({}).then(() => {
+        expect(locReload).to.be.calledWith(false)
+      })
+    })
 
-      return cy.reload({}).then(() => expect(locReload).to.be.calledWith(false));
-    });
+    it('returns the window object', () => {
+      cy
+      .window().then((oldWin) => {
+        oldWin.foo = 'bar'
+        expect(oldWin.foo).to.eq('bar')
 
-    it("returns the window object", () => cy
-      .window().then(function(oldWin) {
-        oldWin.foo = "bar";
-        expect(oldWin.foo).to.eq("bar");
+        cy.reload().then((win) => {
+          expect(win).not.to.be.undefined
+          expect(win.foo).to.be.undefined
 
-        return cy.reload().then(function(win) {
-          expect(win).not.to.be.undefined;
-          expect(win.foo).to.be.undefined;
+          expect(win).to.eq(cy.state('window'))
+        })
+      })
+    })
 
-          return expect(win).to.eq(cy.state("window"));
-        });
-    }));
+    it('removes window:load listeners', () => {
+      const listeners = cy.listeners('window:load')
 
-    it("removes window:load listeners", function() {
-      const listeners = cy.listeners("window:load");
+      const winLoad = cy.spy(cy, 'once').withArgs('window:load')
 
-      const winLoad = cy.spy(cy, "once").withArgs("window:load");
+      cy.reload().then(() => {
+        expect(winLoad).to.be.calledOnce
+        expect(cy.listeners('window:load')).to.deep.eq(listeners)
+      })
+    })
 
-      return cy.reload().then(function() {
-        expect(winLoad).to.be.calledOnce;
+    // TODO: fix this
+    it.skip('(FLAKY) sets timeout to Cypress.config(pageLoadTimeout)', () => {
+      const timeout = cy.spy(Promise.prototype, 'timeout')
 
-        return expect(cy.listeners("window:load")).to.deep.eq(listeners);
-      });
-    });
+      Cypress.config('pageLoadTimeout', 4567)
 
-    //# TODO: fix this
-    it.skip("(FLAKY) sets timeout to Cypress.config(pageLoadTimeout)", function() {
-      const timeout = cy.spy(Promise.prototype, "timeout");
+      cy.reload().then(() => {
+        expect(timeout).to.be.calledWith(4567, 'reload')
+      })
+    })
+
+    it('fires stability:changed and window events events', () => {
+      const stub1 = cy.stub()
+      const stub2 = cy.stub()
+      const stub3 = cy.stub()
+
+      cy.on('stability:changed', stub1)
+      cy.on('window:before:unload', stub2)
+      cy.on('window:unload', stub3)
+
+      cy.reload().then(() => {
+        expect(stub1.firstCall).to.be.calledWith(false, 'beforeunload')
+        expect(stub1.secondCall).to.be.calledWith(true, 'load')
+        expect(stub2).to.be.calledOnce
+        expect(stub3).to.be.calledOnce
+      })
+    })
 
-      Cypress.config("pageLoadTimeout", 4567);
+    it('removes listeners', () => {
+      const win = cy.state('window')
 
-      return cy.reload().then(() => expect(timeout).to.be.calledWith(4567, "reload"));
-    });
+      const rel = cy.stub(win, 'removeEventListener')
 
-    it("fires stability:changed and window events events", function() {
-      const stub1 = cy.stub();
-      const stub2 = cy.stub();
-      const stub3 = cy.stub();
+      cy.reload().then(() => {
+        expect(rel).to.be.calledWith('beforeunload')
+        expect(rel).to.be.calledWith('unload')
+      })
+    })
 
-      cy.on("stability:changed", stub1);
-      cy.on("window:before:unload", stub2);
-      cy.on("window:unload", stub3);
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 100)
 
-      return cy.reload().then(function() {
-        expect(stub1.firstCall).to.be.calledWith(false, "beforeunload");
-        expect(stub1.secondCall).to.be.calledWith(true, "load");
-        expect(stub2).to.be.calledOnce;
-        return expect(stub3).to.be.calledOnce;
-      });
-    });
+        this.logs = []
 
-    it("removes listeners", function() {
-      const win = cy.state("window");
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
 
-      const rel = cy.stub(win, "removeEventListener");
+        return null
+      })
 
-      return cy.reload().then(function() {
-        expect(rel).to.be.calledWith("beforeunload");
-        return expect(rel).to.be.calledWith("unload");
-      });
-    });
+      it('logs once on failure', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
 
-    describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 100);
+          done()
+        })
 
-        this.logs = [];
+        cy.reload(Infinity)
+      })
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+      it('throws passing more than 2 args', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.reload()` can only accept a boolean or `options` as its arguments.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/reload')
 
-        return null;
-      });
+          done()
+        })
+
+        cy.reload(1, 2, 3)
+      })
 
-      it("logs once on failure", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          return done();
-        });
+      it('throws passing 2 invalid arguments', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.reload()` can only accept a boolean or `options` as its arguments.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/reload')
 
-        return cy.reload(Infinity);
-      });
+          done()
+        })
 
-      it("throws passing more than 2 args", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.reload()` can only accept a boolean or `options` as its arguments.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/reload");
-          return done();
-        });
+        cy.reload(true, 1)
+      })
 
-        return cy.reload(1, 2, 3);
-      });
+      it('throws passing 1 invalid argument', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.reload()` can only accept a boolean or `options` as its arguments.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/reload')
 
-      it("throws passing 2 invalid arguments", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.reload()` can only accept a boolean or `options` as its arguments.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/reload");
-          return done();
-        });
+          done()
+        })
 
-        return cy.reload(true, 1);
-      });
+        cy.reload(1)
+      })
 
-      it("throws passing 1 invalid argument", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.reload()` can only accept a boolean or `options` as its arguments.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/reload");
-          return done();
-        });
+      it('fully refreshes page', () => {
+        cy
+        .window().then((win) => {
+          win.foo = 'foo'
+        })
+        .reload()
+        .window().then((win) => {
+          expect(win.foo).to.be.undefined
+        })
+      })
 
-        return cy.reload(1);
-      });
+      it('throws when reload times out', (done) => {
+        cy.timeout(1000)
+        cy.spy(Cypress.utils, 'locReload')
 
-      it("fully refreshes page", () => cy
-        .window().then(win => win.foo = "foo").reload()
-        .window().then(win => expect(win.foo).to.be.undefined));
-
-      return it("throws when reload times out", function(done) {
-        cy.timeout(1000);
-        const locReload = cy.spy(Cypress.utils, "locReload");
-
-        return cy
-          .visit("/timeout?ms=100").then(function() {
-            let expected = false;
-
-            //# wait until the window finishes loading first
-            //# else we can potentially move onto the next test
-            //# while we're still unstable, which will result in
-            //# properties on the window being inaccessible
-            //# since we only visit once at the beginning of these tests
-            cy.on("window:load", function() {
-              expect(expected).to.be.true;
-              return done();
-            });
-
-            return cy.on("fail", function(err) {
-              expected = true;
-
-              return expect(err.message).to.include("Your page did not fire its `load` event within `1ms`.");
-            });}).reload({timeout: 1});
-      });
-    });
+        cy
+        .visit('/timeout?ms=100').then(() => {
+          let expected = false
 
-    return describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
+          // wait until the window finishes loading first
+          // else we can potentially move onto the next test
+          // while we're still unstable, which will result in
+          // properties on the window being inaccessible
+          // since we only visit once at the beginning of these tests
+          cy.on('window:load', () => {
+            expect(expected).to.be.true
 
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "reload") {
-            this.lastLog = log;
-          }
+            done()
+          })
 
-          return this.logs.push(log);
-        });
+          cy.on('fail', (err) => {
+            expected = true
 
-        return null;
-      });
+            expect(err.message).to.include('Your page did not fire its `load` event within `1ms`.')
+          })
+        })
+        .reload({ timeout: 1 })
+      })
+    })
 
-      it("logs reload", () => cy.reload().then(function() {
-        return expect(this.lastLog.get("name")).to.eq("reload");
-      }));
-
-      it("can turn off logging", () => cy.reload({log: false}).then(function() {
-        return expect(this.lastLog).to.be.undefined;
-      }));
-
-      it("does not log 'Page Load' events", () => cy.reload().then(function() {
-        return this.logs.slice(0).forEach(log => expect(log.get("name")).not.eq('page load'));
-      }));
-
-      return it("logs before + after", function() {
-        let beforeunload = false;
-
-        return cy
-          .window().then(function(win) {
-            return cy.on("window:before:unload", () => {
-              const {
-                lastLog
-              } = this;
-
-              beforeunload = true;
-              expect(lastLog.get("snapshots").length).to.eq(1);
-              expect(lastLog.get("snapshots")[0].name).to.eq("before");
-              expect(lastLog.get("snapshots")[0].body).to.be.an("object");
-
-              return undefined;
-            });}).reload().then(function() {
-            const {
-              lastLog
-            } = this;
-
-            expect(beforeunload).to.be.true;
-            expect(lastLog.get("snapshots").length).to.eq(2);
-            expect(lastLog.get("snapshots")[1].name).to.eq("after");
-            return expect(lastLog.get("snapshots")[1].body).to.be.an("object");
-        });
-      });
-    });
-  });
-
-  context("#go", function() {
-    before(() => cy
-      .visit("/fixtures/generic.html")
-      .then(function(win) {
-        return this.body = win.document.body.outerHTML;
-    }));
-
-    beforeEach(function() {
-      const doc = cy.state("document");
-
-      return $(doc.body).empty().html(this.body);
-    });
-
-    //# TODO: fix this
-    it.skip("(FLAKY) sets timeout to Cypress.config(pageLoadTimeout)", function() {
-      const timeout = cy.spy(Promise.prototype, "timeout");
-      Cypress.config("pageLoadTimeout", 4567);
-
-      return cy
-        .visit("/fixtures/jquery.html")
-        .go("back").then(() => expect(timeout).to.be.calledWith(4567, "go"));
-    });
-
-    it("removes listeners", () => cy
-      .visit("/fixtures/generic.html")
-      .visit("/fixtures/jquery.html")
-      .then(function() {
-        const winLoadListeners = cy.listeners("window:load");
-        const beforeWinUnloadListeners = cy.listeners("window:before:unload");
-
-        const cyOn = cy.spy(cy, "once");
-
-        const winLoad = cyOn.withArgs("window:load");
-        const beforeWinUnload = cyOn.withArgs("window:before:unload");
-
-        return cy.go("back").then(function() {
-          expect(winLoad).to.be.calledOnce;
-          expect(beforeWinUnload).to.be.calledOnce;
-
-          expect(cy.listeners("window:load")).to.deep.eq(winLoadListeners);
-          return expect(cy.listeners("window:before:unload")).to.deep.eq(beforeWinUnloadListeners);
-        });
-    }));
-
-    it("fires stability:changed and window events events", function() {
-      const stub1= cy.stub();
-      const stub2 = cy.stub();
-      const stub3 = cy.stub();
-
-      return cy
-        .visit("/fixtures/generic.html")
-        .visit("/fixtures/jquery.html")
-        .then(function() {
-          cy.on("stability:changed", stub1);
-          cy.on("window:before:unload", stub2);
-          return cy.on("window:unload", stub3);}).go("back").then(function() {
-          expect(stub1.firstCall).to.be.calledWith(false, "beforeunload");
-          expect(stub1.secondCall).to.be.calledWith(true, "load");
-          expect(stub2).to.be.calledOnce;
-          return expect(stub3).to.be.calledOnce;
-      });
-    });
-
-    it("removes listeners from window", () => cy
-      .visit("/fixtures/generic.html")
-      .visit("/fixtures/jquery.html")
-      .then(function(win) {
-        const rel = cy.stub(win, "removeEventListener");
-
-        return cy.go("back").then(function() {
-          expect(rel).to.be.calledWith("beforeunload");
-          return expect(rel).to.be.calledWith("unload");
-        });
-    }));
-
-    describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 50);
-
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "go") {
-            this.lastLog = log;
-            return this.logs.push(log);
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'reload') {
+            this.lastLog = log
           }
-        });
 
-        return null;
-      });
+          this.logs.push(log)
+        })
 
-      _.each([null, undefined, NaN, Infinity, {}, [], () => ({})], val => {
-        return it(`throws on: '${val}'`, function(done) {
-          cy.on("fail", function(err) {
-            expect(err.message).to.eq("`cy.go()` accepts only a string or number argument");
-            expect(err.docsUrl).to.eq("https://on.cypress.io/go");
-            return done();
-          });
+        return null
+      })
 
-          return cy.go(val);
-        });
-      });
+      it('logs reload', () => {
+        cy.reload().then(function () {
+          expect(this.lastLog.get('name')).to.eq('reload')
+        })
+      })
 
-      it("throws on invalid string", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.go()` accepts either `forward` or `back`. You passed: `foo`");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/go");
+      it('can turn off logging', () => {
+        cy.reload({ log: false }).then(function () {
+          expect(this.lastLog).to.be.undefined
+        })
+      })
 
-          return done();
-        });
+      it('does not log \'Page Load\' events', () => {
+        cy.reload().then(function () {
+          this.logs.slice(0).forEach((log) => {
+            expect(log.get('name')).not.eq('page load')
+          })
+        })
+      })
 
-        return cy.go("foo");
-      });
+      it('logs before + after', () => {
+        let beforeunload = false
 
-      it("throws on zero", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.go()` cannot accept `0`. The number must be greater or less than `0`.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/go");
+        cy
+        .window().then(function () {
+          cy.on('window:before:unload', () => {
+            const { lastLog } = this
 
-          return done();
-        });
+            beforeunload = true
+            expect(lastLog.get('snapshots').length).to.eq(1)
+            expect(lastLog.get('snapshots')[0].name).to.eq('before')
+            expect(lastLog.get('snapshots')[0].body).to.be.an('object')
 
-        return cy.go(0);
-      });
+            return undefined
+          })
+        }).reload().then(function () {
+          const { lastLog } = this
 
-      it("throws when go times out", function(done) {
-        cy.timeout(1000);
-        return cy
-          .visit("/timeout?ms=100")
-          .visit("/fixtures/jquery.html")
-          .then(function() {
-            let expected = false;
-
-            //# wait until the window finishes loading first
-            //# else we can potentially move onto the next test
-            //# while we're still unstable, which will result in
-            //# properties on the window being inaccessible
-            //# since we only visit once at the beginning of these tests
-            cy.on("window:load", function() {
-              expect(expected).to.be.true;
-              return done();
-            });
-
-            cy.on("fail", function(err) {
-              expected = true;
-
-              return expect(err.message).to.include("Your page did not fire its `load` event within `1ms`.");
-            });
-
-            return cy.go("back", {timeout: 1});
-        });
-      });
+          expect(beforeunload).to.be.true
+          expect(lastLog.get('snapshots').length).to.eq(2)
+          expect(lastLog.get('snapshots')[1].name).to.eq('after')
 
-      return it("only logs once on error", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(this.logs[0].get("error")).to.eq(err);
-          return done();
-        });
+          expect(lastLog.get('snapshots')[1].body).to.be.an('object')
+        })
+      })
+    })
+  })
+
+  context('#go', () => {
+    before(() => {
+      cy
+      .visit('/fixtures/generic.html')
+      .then(function (win) {
+        this.body = win.document.body.outerHTML
+      })
+    })
 
-        return cy
-          .visit("/fixtures/jquery.html")
-          .go("back", {timeout: 1});
-      });
-    });
+    beforeEach(function () {
+      const doc = cy.state('document')
+
+      $(doc.body).empty().html(this.body)
+    })
 
-    return describe(".log", function() {
-      beforeEach(() => cy.visit("/fixtures/generic.html").then(function() {
-        this.logs = [];
+    // TODO: fix this
+    it.skip('(FLAKY) sets timeout to Cypress.config(pageLoadTimeout)', () => {
+      const timeout = cy.spy(Promise.prototype, 'timeout')
 
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "go") {
-            this.lastLog = log;
+      Cypress.config('pageLoadTimeout', 4567)
+
+      cy
+      .visit('/fixtures/jquery.html')
+      .go('back').then(() => {
+        expect(timeout).to.be.calledWith(4567, 'go')
+      })
+    })
+
+    it('removes listeners', () => {
+      cy
+      .visit('/fixtures/generic.html')
+      .visit('/fixtures/jquery.html')
+      .then(() => {
+        const winLoadListeners = cy.listeners('window:load')
+        const beforeWinUnloadListeners = cy.listeners('window:before:unload')
+
+        const cyOn = cy.spy(cy, 'once')
+
+        const winLoad = cyOn.withArgs('window:load')
+        const beforeWinUnload = cyOn.withArgs('window:before:unload')
+
+        cy.go('back').then(() => {
+          expect(winLoad).to.be.calledOnce
+          expect(beforeWinUnload).to.be.calledOnce
+
+          expect(cy.listeners('window:load')).to.deep.eq(winLoadListeners)
+          expect(cy.listeners('window:before:unload')).to.deep.eq(beforeWinUnloadListeners)
+        })
+      })
+    })
+
+    it('fires stability:changed and window events events', () => {
+      const stub1 = cy.stub()
+      const stub2 = cy.stub()
+      const stub3 = cy.stub()
+
+      cy
+      .visit('/fixtures/generic.html')
+      .visit('/fixtures/jquery.html')
+      .then(() => {
+        cy.on('stability:changed', stub1)
+        cy.on('window:before:unload', stub2)
+        cy.on('window:unload', stub3)
+      })
+      .go('back').then(() => {
+        expect(stub1.firstCall).to.be.calledWith(false, 'beforeunload')
+        expect(stub1.secondCall).to.be.calledWith(true, 'load')
+        expect(stub2).to.be.calledOnce
+        expect(stub3).to.be.calledOnce
+      })
+    })
+
+    it('removes listeners from window', () => {
+      cy
+      .visit('/fixtures/generic.html')
+      .visit('/fixtures/jquery.html')
+      .then((win) => {
+        const rel = cy.stub(win, 'removeEventListener')
+
+        cy.go('back').then(() => {
+          expect(rel).to.be.calledWith('beforeunload')
+          expect(rel).to.be.calledWith('unload')
+        })
+      })
+    })
+
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'go') {
+            this.lastLog = log
+            this.logs.push(log)
           }
+        })
 
-          return this.logs.push(log);
-        });
-
-        return null;
-      }));
-
-      it("logs go", () => cy
-        .visit("/fixtures/jquery.html")
-        .go("back").then(function() {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("name")).to.eq("go");
-          return expect(lastLog.get("message")).to.eq("back");
-      }));
-
-      it("can turn off logging", () => cy
-        .visit("/fixtures/jquery.html")
-        .go("back", {log: false}).then(function() {
-          return expect(this.lastLog).to.be.undefined;
-      }));
-
-      it("does not log 'Page Load' events", () => cy
-        .visit("/fixtures/jquery.html")
-        .go("back").then(function() {
-          return this.logs.slice(0).forEach(log => expect(log.get("name")).not.eq('page load'));
-      }));
-
-      return it("logs before + after", function() {
-        let beforeunload = false;
-
-        return cy
-          .visit("/fixtures/jquery.html")
-          .window().then(function(win) {
-            cy.on("window:before:unload", () => {
-              const {
-                lastLog
-              } = this;
-
-              beforeunload = true;
-              expect(lastLog.get("snapshots").length).to.eq(1);
-              expect(lastLog.get("snapshots")[0].name).to.eq("before");
-              expect(lastLog.get("snapshots")[0].body).to.be.an("object");
-
-              return undefined;
-            });
-
-            return cy.go("back").then(function() {
-              const {
-                lastLog
-              } = this;
-
-              expect(beforeunload).to.be.true;
-              expect(lastLog.get("snapshots").length).to.eq(2);
-              expect(lastLog.get("snapshots")[1].name).to.eq("after");
-              return expect(lastLog.get("snapshots")[1].body).to.be.an("object");
-            });
-        });
-      });
-    });
-  });
+        return null
+      })
+
+      _.each([null, undefined, NaN, Infinity, {}, [], () => {}], (val) => {
+        it(`throws on: '${val}'`, (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('`cy.go()` accepts only a string or number argument')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/go')
+
+            done()
+          })
 
-  context("#visit", function() {
-    //# TODO: fix this
-    it.skip("(FLAKY) sets timeout to Cypress.config(pageLoadTimeout)", function() {
-      const timeout = cy.spy(Promise.prototype, "timeout");
+          cy.go(val)
+        })
+      })
 
-      Cypress.config("pageLoadTimeout", 4567);
+      it('throws on invalid string', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.go()` accepts either `forward` or `back`. You passed: `foo`')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/go')
 
-      return cy.visit("/fixtures/jquery.html").then(() => expect(timeout).to.be.calledWith(4567));
-    });
+          done()
+        })
 
-    it("removes window:load listeners", function() {
-      const listeners = cy.listeners("window:load");
+        cy.go('foo')
+      })
 
-      const winLoad = cy.spy(cy, "once").withArgs("window:load");
+      it('throws on zero', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.go()` cannot accept `0`. The number must be greater or less than `0`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/go')
 
-      return cy.visit("/fixtures/generic.html").then(function() {
-        //# once for about:blank, once for $iframe src
-        expect(winLoad).to.be.calledTwice;
+          done()
+        })
 
-        return expect(cy.listeners("window:load")).to.deep.eq(listeners);
-      });
-    });
+        cy.go(0)
+      })
 
-    it("can visit pages on the same originPolicy", () => cy
-      .visit("http://localhost:3500/fixtures/jquery.html")
-      .visit("http://localhost:3500/fixtures/generic.html")
-      .visit("http://localhost:3500/fixtures/dimensions.html"));
+      it('throws when go times out', (done) => {
+        cy.timeout(1000)
 
-    it("resolves the subject to the remote iframe window", () => cy.visit("/fixtures/jquery.html").then(win => expect(win).to.eq(cy.state("$autIframe").prop("contentWindow"))));
+        cy
+        .visit('/timeout?ms=100')
+        .visit('/fixtures/jquery.html')
+        .then(() => {
+          let expected = false
 
-    it("changes the src of the iframe to the initial src", () => cy.visit("/fixtures/jquery.html").then(function() {
-      const src = cy.state("$autIframe").attr("src");
-      return expect(src).to.eq("http://localhost:3500/fixtures/jquery.html");
-    }));
+          // wait until the window finishes loading first
+          // else we can potentially move onto the next test
+          // while we're still unstable, which will result in
+          // properties on the window being inaccessible
+          // since we only visit once at the beginning of these tests
+          cy.on('window:load', () => {
+            expect(expected).to.be.true
 
-    it("invokes onLoad callback", function(done) {
-      const ctx = this;
+            done()
+          })
 
-      return cy.visit("/fixtures/jquery.html", {
-        onLoad(contentWindow) {
-          const thisValue = this === ctx;
+          cy.on('fail', (err) => {
+            expected = true
 
-          expect(thisValue).be.true;
-          expect(!!contentWindow.Cypress).to.be.true;
-          return done();
-        }
-      });
-    });
+            expect(err.message).to.include('Your page did not fire its `load` event within `1ms`.')
+          })
 
-    it("invokes onBeforeLoad callback with cy context", function(done) {
-      const ctx = this;
+          cy.go('back', { timeout: 1 })
+        })
+      })
 
-      return cy.visit("/fixtures/jquery.html", {
-        onBeforeLoad(contentWindow) {
-          const thisValue = this === ctx;
+      it('only logs once on error', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+          expect(this.logs[0].get('error')).to.eq(err)
 
-          expect(thisValue).be.true;
+          done()
+        })
 
-          expect(!!contentWindow.Cypress).to.be.true;
-          return done();
-        }
-      });
-    });
+        cy
+        .visit('/fixtures/jquery.html')
+        .go('back', { timeout: 1 })
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(() => {
+        cy.visit('/fixtures/generic.html').then(function () {
+          this.logs = []
+
+          cy.on('log:added', (attrs, log) => {
+            if (attrs.name === 'go') {
+              this.lastLog = log
+            }
+
+            this.logs.push(log)
+          })
+
+          return null
+        })
+      })
+
+      it('logs go', () => {
+        cy
+        .visit('/fixtures/jquery.html')
+        .go('back').then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('name')).to.eq('go')
+          expect(lastLog.get('message')).to.eq('back')
+        })
+      })
+
+      it('can turn off logging', () => {
+        cy
+        .visit('/fixtures/jquery.html')
+        .go('back', { log: false }).then(function () {
+          expect(this.lastLog).to.be.undefined
+        })
+      })
+
+      it('does not log \'Page Load\' events', () => {
+        cy
+        .visit('/fixtures/jquery.html')
+        .go('back').then(function () {
+          this.logs.slice(0).forEach((log) => {
+            expect(log.get('name')).not.eq('page load')
+          })
+        })
+      })
+
+      it('logs before + after', () => {
+        let beforeunload = false
+
+        cy
+        .visit('/fixtures/jquery.html')
+        .window().then(function (win) {
+          cy.on('window:before:unload', () => {
+            const { lastLog } = this
+
+            beforeunload = true
+            expect(lastLog.get('snapshots').length).to.eq(1)
+            expect(lastLog.get('snapshots')[0].name).to.eq('before')
+            expect(lastLog.get('snapshots')[0].body).to.be.an('object')
+
+            return undefined
+          })
+
+          cy.go('back').then(function () {
+            const { lastLog } = this
 
-    it("does not error without an onBeforeLoad callback", () => cy.visit("/fixtures/jquery.html").then(function() {
-      const prev = cy.state("current").get("prev");
-      return expect(prev.get("args")).to.have.length(1);
-    }));
+            expect(beforeunload).to.be.true
+            expect(lastLog.get('snapshots').length).to.eq(2)
+            expect(lastLog.get('snapshots')[1].name).to.eq('after')
+            expect(lastLog.get('snapshots')[1].body).to.be.an('object')
+          })
+        })
+      })
+    })
+  })
+
+  context('#visit', () => {
+    // TODO: fix this
+    it.skip('(FLAKY) sets timeout to Cypress.config(pageLoadTimeout)', () => {
+      const timeout = cy.spy(Promise.prototype, 'timeout')
+
+      Cypress.config('pageLoadTimeout', 4567)
+
+      cy.visit('/fixtures/jquery.html').then(() => {
+        expect(timeout).to.be.calledWith(4567)
+      })
+    })
+
+    it('removes window:load listeners', () => {
+      const listeners = cy.listeners('window:load')
+
+      const winLoad = cy.spy(cy, 'once').withArgs('window:load')
+
+      cy.visit('/fixtures/generic.html').then(() => {
+        // once for about:blank, once for $iframe src
+        expect(winLoad).to.be.calledTwice
+        expect(cy.listeners('window:load')).to.deep.eq(listeners)
+      })
+    })
+
+    it('can visit pages on the same originPolicy', () => {
+      cy
+      .visit('http://localhost:3500/fixtures/jquery.html')
+      .visit('http://localhost:3500/fixtures/generic.html')
+      .visit('http://localhost:3500/fixtures/dimensions.html')
+    })
+
+    it('resolves the subject to the remote iframe window', () => {
+      cy.visit('/fixtures/jquery.html').then((win) => {
+        expect(win).to.eq(cy.state('$autIframe').prop('contentWindow'))
+      })
+    })
+
+    it('changes the src of the iframe to the initial src', () => {
+      cy.visit('/fixtures/jquery.html').then(() => {
+        const src = cy.state('$autIframe').attr('src')
+
+        expect(src).to.eq('http://localhost:3500/fixtures/jquery.html')
+      })
+    })
+
+    it('invokes onLoad callback', function (done) {
+      const ctx = this
+
+      cy.visit('/fixtures/jquery.html', {
+        onLoad (contentWindow) {
+          const thisValue = this === ctx
+
+          expect(thisValue).be.true
+          expect(!!contentWindow.Cypress).to.be.true
+
+          done()
+        },
+      })
+    })
 
-    it("calls resolve:url with http:// when localhost", function() {
-      const backend = cy.spy(Cypress, "backend");
+    it('invokes onBeforeLoad callback with cy context', function (done) {
+      const ctx = this
 
-      return cy
-        .visit("localhost:3500/timeout")
-        .then(() => expect(backend).to.be.calledWith("resolve:url", "http://localhost:3500/timeout"));
-    });
+      cy.visit('/fixtures/jquery.html', {
+        onBeforeLoad (contentWindow) {
+          const thisValue = this === ctx
 
-    it("prepends hostname when visiting locally", function() {
-      const prop = cy.spy(cy.state("$autIframe"), "prop");
+          expect(thisValue).be.true
 
-      return cy
-        .visit("fixtures/jquery.html")
-        .then(() => expect(prop).to.be.calledWith("src", "http://localhost:3500/fixtures/jquery.html"));
-    });
+          expect(!!contentWindow.Cypress).to.be.true
 
-    it("can visit relative pages on the same originPolicy", () => //# as long as we are already on the localhost:3500
-    //# domain this will work
+          done()
+        },
+      })
+    })
 
-    cy
-      .visit("http://localhost:3500/fixtures/dimensions.html")
-      .visit("/fixtures/jquery.html"));
+    it('does not error without an onBeforeLoad callback', () => {
+      cy.visit('/fixtures/jquery.html').then(() => {
+        const prev = cy.state('current').get('prev')
 
-    it("can visit relative pages with domain like query params", () => cy
-      .visit("http://localhost:3500/fixtures/generic.html")
-      .visit("http://localhost:3500/fixtures/dimensions.html?email=briancypress.io"));
+        expect(prev.get('args')).to.have.length(1)
+      })
+    })
 
-    it("can visit pages with non-2xx status codes when option failOnStatusCode is false", () => cy
-      .visit("localhost:3500/status-404", { failOnStatusCode: false })
-      .visit("localhost:3500/status-500", { failOnStatusCode: false }));
+    it('calls resolve:url with http:// when localhost', () => {
+      const backend = cy.spy(Cypress, 'backend')
 
-    it("strips username + password out of the url when provided", function() {
-      const backend = cy.spy(Cypress, "backend");
+      cy
+      .visit('localhost:3500/timeout')
+      .then(() => {
+        expect(backend).to.be.calledWith('resolve:url', 'http://localhost:3500/timeout')
+      })
+    })
 
-      return cy
-        .visit("http://cypress:password123@localhost:3500/timeout")
-        .then(() => expect(backend).to.be.calledWith("resolve:url", "http://localhost:3500/timeout"));
-    });
+    it('prepends hostname when visiting locally', () => {
+      const prop = cy.spy(cy.state('$autIframe'), 'prop')
 
-    it("passes auth options", function() {
-      const backend = cy.spy(Cypress, "backend");
+      cy
+      .visit('fixtures/jquery.html')
+      .then(() => {
+        expect(prop).to.be.calledWith('src', 'http://localhost:3500/fixtures/jquery.html')
+      })
+    })
+
+    it('can visit relative pages on the same originPolicy', () => {
+      // as long as we are already on the localhost:3500
+      // domain this will work
+      cy
+      .visit('http://localhost:3500/fixtures/dimensions.html')
+      .visit('/fixtures/jquery.html')
+    })
+
+    it('can visit relative pages with domain like query params', () => {
+      cy
+      .visit('http://localhost:3500/fixtures/generic.html')
+      .visit('http://localhost:3500/fixtures/dimensions.html?email=briancypress.io')
+    })
+
+    it('can visit pages with non-2xx status codes when option failOnStatusCode is false', () => {
+      cy
+      .visit('localhost:3500/status-404', { failOnStatusCode: false })
+      .visit('localhost:3500/status-500', { failOnStatusCode: false })
+    })
+
+    it('strips username + password out of the url when provided', () => {
+      const backend = cy.spy(Cypress, 'backend')
+
+      cy
+      .visit('http://cypress:password123@localhost:3500/timeout')
+      .then(() => {
+        expect(backend).to.be.calledWith('resolve:url', 'http://localhost:3500/timeout')
+      })
+    })
+
+    it('passes auth options', () => {
+      const backend = cy.spy(Cypress, 'backend')
 
       const auth = {
-        username: "cypress",
-        password: "password123"
-      };
+        username: 'cypress',
+        password: 'password123',
+      }
+
+      cy
+      .visit('http://localhost:3500/timeout', { auth })
+      .then(() => {
+        expect(backend).to.be.calledWithMatch('resolve:url', 'http://localhost:3500/timeout', { auth })
+      })
+    })
 
-      return cy
-        .visit("http://localhost:3500/timeout", { auth })
-        .then(() => expect(backend).to.be.calledWithMatch("resolve:url", "http://localhost:3500/timeout", { auth }));
-    });
+    it('does not support file:// protocol', (done) => {
+      Cypress.config('baseUrl', '')
 
-    it("does not support file:// protocol", function(done) {
-      Cypress.config("baseUrl", "");
+      cy.on('fail', (err) => {
+        expect(err.message).to.contain('`cy.visit()` failed because the \'file://...\' protocol is not supported by Cypress.')
 
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.visit()` failed because the 'file://...' protocol is not supported by Cypress.");
-        return done();
-      });
+        done()
+      })
 
-      return cy.visit("file:///cypress/fixtures/generic.html");
-    });
+      cy.visit('file:///cypress/fixtures/generic.html')
+    })
 
-    //# https://github.com/cypress-io/cypress/issues/1727
-    it("can visit a page with undefined content type and html-shaped body", () => cy
-      .visit("http://localhost:3500/undefined-content-type"));
+    // https://github.com/cypress-io/cypress/issues/1727
+    it('can visit a page with undefined content type and html-shaped body', () => {
+      cy.visit('http://localhost:3500/undefined-content-type')
+    })
 
-    describe("when only hashes are changing", () => it("short circuits the visit if the page will not refresh", function() {
-      let count = 0;
-      const urls = [];
+    describe('when only hashes are changing', () => {
+      it('short circuits the visit if the page will not refresh', () => {
+        let count = 0
+        const urls = []
 
-      cy.on("window:load", function() {
-        urls.push(cy.state("window").location.href);
+        cy.on('window:load', () => {
+          urls.push(cy.state('window').location.href)
 
-        return count += 1;
-      });
+          count += 1
+        })
 
-      return cy
-        //# about:blank yes (1)
-        .visit("/fixtures/generic.html?foo#bar") //# yes (2)
-        .visit("/fixtures/generic.html?foo#foo") //# no (2)
-        .visit("/fixtures/generic.html?bar#bar") //# yes (3)
-        .visit("/fixtures/dimensions.html?bar#bar") //# yes (4)
-        .visit("/fixtures/dimensions.html?baz#bar") //# yes (5)
-        .visit("/fixtures/dimensions.html#bar") //# yes (6)
-        .visit("/fixtures/dimensions.html") //# yes (7)
-        .visit("/fixtures/dimensions.html#baz") //# no (7)
-        .visit("/fixtures/dimensions.html#") //# no (7)
-        .then(function() {
-          expect(count).to.eq(7);
-          return expect(urls).to.deep.eq([
-            "about:blank",
-            "http://localhost:3500/fixtures/generic.html?foo#bar",
-            "http://localhost:3500/fixtures/generic.html?bar#bar",
-            "http://localhost:3500/fixtures/dimensions.html?bar#bar",
-            "http://localhost:3500/fixtures/dimensions.html?baz#bar",
-            "http://localhost:3500/fixtures/dimensions.html#bar",
-            "http://localhost:3500/fixtures/dimensions.html"
-          ]);
-      });
-    }));
-
-    //# https://github.com/cypress-io/cypress/issues/1311
-    it("window immediately resolves and doesn't reload when visiting the same URL with hashes", function() {
-      const onLoad = cy.stub();
-
-      return cy
-        .visit("http://localhost:3500/fixtures/generic.html#foo").then(win => win.foo = 'bar').visit("http://localhost:3500/fixtures/generic.html#foo", {
-          onLoad
-        }).then(function(win) {
-          expect(win.bar).to.not.exist;
-          return expect(onLoad).not.to.have.been.called;
-      });
-    });
+        cy
+        // about:blank yes (1)
+        .visit('/fixtures/generic.html?foo#bar') // yes (2)
+        .visit('/fixtures/generic.html?foo#foo') // no (2)
+        .visit('/fixtures/generic.html?bar#bar') // yes (3)
+        .visit('/fixtures/dimensions.html?bar#bar') // yes (4)
+        .visit('/fixtures/dimensions.html?baz#bar') // yes (5)
+        .visit('/fixtures/dimensions.html#bar') // yes (6)
+        .visit('/fixtures/dimensions.html') // yes (7)
+        .visit('/fixtures/dimensions.html#baz') // no (7)
+        .visit('/fixtures/dimensions.html#') // no (7)
+        .then(() => {
+          expect(count).to.eq(7)
+
+          expect(urls).to.deep.eq([
+            'about:blank',
+            'http://localhost:3500/fixtures/generic.html?foo#bar',
+            'http://localhost:3500/fixtures/generic.html?bar#bar',
+            'http://localhost:3500/fixtures/dimensions.html?bar#bar',
+            'http://localhost:3500/fixtures/dimensions.html?baz#bar',
+            'http://localhost:3500/fixtures/dimensions.html#bar',
+            'http://localhost:3500/fixtures/dimensions.html',
+          ])
+        })
+      })
+    })
+
+    // https://github.com/cypress-io/cypress/issues/1311
+    it('window immediately resolves and doesn\'t reload when visiting the same URL with hashes', () => {
+      const onLoad = cy.stub()
+
+      cy
+      .visit('http://localhost:3500/fixtures/generic.html#foo').then((win) => {
+        win.foo = 'bar'
+      })
+      .visit('http://localhost:3500/fixtures/generic.html#foo', {
+        onLoad,
+      })
+      .then((win) => {
+        expect(win.bar).to.not.exist
+        expect(onLoad).not.to.have.been.called
+      })
+    })
 
-    it("can send headers", function() {
+    it('can send headers', () => {
       cy.visit({
-        url: "http://localhost:3500/dump-headers",
+        url: 'http://localhost:3500/dump-headers',
         headers: {
-          "x-foo-baz": "bar-quux"
-        }
-      });
-      return cy.contains('"x-foo-baz":"bar-quux"');
-    });
+          'x-foo-baz': 'bar-quux',
+        },
+      })
+
+      cy.contains('"x-foo-baz":"bar-quux"')
+    })
 
-    it("can send user-agent header", function() {
+    it('can send user-agent header', () => {
       cy.visit({
-        url: "http://localhost:3500/dump-headers",
+        url: 'http://localhost:3500/dump-headers',
         headers: {
-          "user-agent": "something special"
-        }
-      });
-      return cy.contains('"user-agent":"something special"');
-    });
+          'user-agent': 'something special',
+        },
+      })
 
-    it("can send querystring params", function() {
-      const qs = { "foo bar": "baz quux" };
+      cy.contains('"user-agent":"something special"')
+    })
 
-      return cy
-        .visit("http://localhost:3500/dump-qs", { qs })
-        .then(function() {
-          cy.contains(JSON.stringify(qs));
-          return cy.url().should('eq', 'http://localhost:3500/dump-qs?foo%20bar=baz%20quux');
-      });
-    });
+    it('can send querystring params', () => {
+      const qs = { 'foo bar': 'baz quux' }
+
+      cy
+      .visit('http://localhost:3500/dump-qs', { qs })
+      .then(() => {
+        cy.contains(JSON.stringify(qs))
 
-    describe("can send a POST request", function() {
-      it("automatically urlencoded using an object body", function() {
-        cy.visit("http://localhost:3500/post-only", {
-          method: "POST",
+        cy.url().should('eq', 'http://localhost:3500/dump-qs?foo%20bar=baz%20quux')
+      })
+    })
+
+    describe('can send a POST request', () => {
+      it('automatically urlencoded using an object body', () => {
+        cy.visit('http://localhost:3500/post-only', {
+          method: 'POST',
           body: {
-            bar: "baz"
-          }
-        });
-        return cy.contains("it worked!").contains("{\"bar\":\"baz\"}");
-      });
+            bar: 'baz',
+          },
+        })
+
+        cy.contains('it worked!').contains('{"bar":"baz"}')
+      })
 
-      return it("with any string body and headers", function() {
-        cy.visit("http://localhost:3500/post-only", {
-          method: "POST",
+      it('with any string body and headers', () => {
+        cy.visit('http://localhost:3500/post-only', {
+          method: 'POST',
           headers: {
-            "content-type": "application/json"
+            'content-type': 'application/json',
           },
           body: JSON.stringify({
-            bar: "baz"
-          })
-        });
-        return cy.contains("it worked!").contains("{\"bar\":\"baz\"}");
-      });
-    });
-
-    describe("when origins don't match", function() {
-      beforeEach(function() {
-        Cypress.emit("test:before:run", { id: 888 });
-
-        cy.stub(Cypress, "getEmissions").returns([]);
-        cy.stub(Cypress, "getTestsState").returns([]);
-        cy.stub(Cypress, "getStartTime").returns("12345");
-        cy.stub(Cypress.Log, "countLogsByTests").withArgs([]).returns(1);
-        return cy.stub(Cypress, "countByTestState")
-        .withArgs([], "passed").returns(2)
-        .withArgs([], "failed").returns(3)
-        .withArgs([], "pending").returns(4);
-      });
+            bar: 'baz',
+          }),
+        })
+
+        cy.contains('it worked!').contains('{"bar":"baz"}')
+      })
+    })
+
+    describe('when origins don\'t match', () => {
+      beforeEach(() => {
+        Cypress.emit('test:before:run', { id: 888 })
+
+        cy.stub(Cypress, 'getEmissions').returns([])
+        cy.stub(Cypress, 'getTestsState').returns([])
+        cy.stub(Cypress, 'getStartTime').returns('12345')
+        cy.stub(Cypress.Log, 'countLogsByTests').withArgs([]).returns(1)
+        cy.stub(Cypress, 'countByTestState')
+        .withArgs([], 'passed').returns(2)
+        .withArgs([], 'failed').returns(3)
+        .withArgs([], 'pending').returns(4)
+      })
 
-      it("emits preserve:run:state with title + fn", function(done) {
+      it('emits preserve:run:state with title + fn', (done) => {
         const obj = {
           currentId: 888,
           tests: [],
           emissions: [],
-          startTime: "12345",
+          startTime: '12345',
           numLogs: 1,
           passed: 2,
           failed: 3,
-          pending: 4
-        };
+          pending: 4,
+        }
 
-        const fn = function(eventName, state) {
-          _.each(obj, (value, key) => expect(state[key]).to.deep.eq(value));
+        const fn = function (eventName, state) {
+          _.each(obj, (value, key) => {
+            expect(state[key]).to.deep.eq(value)
+          })
 
-          return done();
-        };
+          done()
+        }
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          url: "http://localhost:4200"
+          url: 'http://localhost:4200',
         })
-        .withArgs("preserve:run:state")
-        .callsFake(fn);
+        .withArgs('preserve:run:state')
+        .callsFake(fn)
 
-        return cy.visit("http://localhost:4200");
-      });
+        cy.visit('http://localhost:4200')
+      })
 
-      return it("replaces window.location when origins don't match", function(done) {
-        const fn = function(str, win) {
-          const isEqual = win === top.window;
+      it('replaces window.location when origins don\'t match', (done) => {
+        const fn = function (str, win) {
+          const isEqual = win === top.window
 
-          expect(isEqual).to.be.true;
-          expect(str).to.eq("http://localhost:4200/foo?bar=baz#/tests/integration/foo_spec.js");
+          expect(isEqual).to.be.true
+          expect(str).to.eq('http://localhost:4200/foo?bar=baz#/tests/integration/foo_spec.js')
 
-          return done();
-        };
+          done()
+        }
 
-        const fakeUrl = Cypress.Location.create("http://localhost:3500/foo?bar=baz#/tests/integration/foo_spec.js");
+        const fakeUrl = Cypress.Location.create('http://localhost:3500/foo?bar=baz#/tests/integration/foo_spec.js')
 
-        cy.stub(Cypress.utils, "locExisting").returns(fakeUrl);
-        cy.stub(Cypress.utils, "locHref")
+        cy.stub(Cypress.utils, 'locExisting').returns(fakeUrl)
+        cy.stub(Cypress.utils, 'locHref')
         .callThrough()
-        .withArgs("http://localhost:4200/foo?bar=baz#/tests/integration/foo_spec.js")
-        .callsFake(fn);
+        .withArgs('http://localhost:4200/foo?bar=baz#/tests/integration/foo_spec.js')
+        .callsFake(fn)
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          url: "http://localhost:4200"
+          url: 'http://localhost:4200',
         })
-        .withArgs("preserve:run:state")
-        .resolves();
+        .withArgs('preserve:run:state')
+        .resolves()
 
-        return cy.visit("http://localhost:4200");
-      });
-    });
-
-    describe("location getter overrides", function() {
-      before(() => cy
-        .visit("/fixtures/jquery.html?foo=bar#dashboard?baz=quux")
-        .window().as("win").then(win => //# ensure href always returns the full path
-      //# so our tests guarantee that in fact we are
-      //# overriding the location getters
-      expect(win.location.href).to.include("/fixtures/jquery.html?foo=bar#dashboard?baz=quux")));
-
-      beforeEach(function() {
-        this.win = cy.state("window");
-
-        return this.eq = (attr, str) => {
-          return expect(this.win.location[attr]).to.eq(str);
-        };
-      });
+        cy.visit('http://localhost:4200')
+      })
+    })
+
+    describe('location getter overrides', () => {
+      before(() => {
+        cy
+        .visit('/fixtures/jquery.html?foo=bar#dashboard?baz=quux')
+        .window().as('win').then((win) => {
+          // ensure href always returns the full path
+          // so our tests guarantee that in fact we are
+          // overriding the location getters
+          expect(win.location.href).to.include('/fixtures/jquery.html?foo=bar#dashboard?baz=quux')
+        })
+      })
 
-      it("hash", function() {
-        return this.eq("hash", "#dashboard?baz=quux");
-      });
+      beforeEach(function () {
+        this.win = cy.state('window')
 
-      it("hostname", function() {
-        return this.eq("hostname", "localhost");
-      });
+        this.eq = (attr, str) => {
+          expect(this.win.location[attr]).to.eq(str)
+        }
+      })
 
-      it("origin", function() {
-        return this.eq("origin", "http://localhost:3500");
-      });
+      it('hash', function () {
+        this.eq('hash', '#dashboard?baz=quux')
+      })
 
-      it("pathname", function() {
-        return this.eq("pathname", "/fixtures/jquery.html");
-      });
+      it('hostname', function () {
+        this.eq('hostname', 'localhost')
+      })
 
-      it("port", function() {
-        return this.eq("port", "3500");
-      });
+      it('origin', function () {
+        this.eq('origin', 'http://localhost:3500')
+      })
 
-      it("protocol", function() {
-        return this.eq("protocol", "http:");
-      });
+      it('pathname', function () {
+        this.eq('pathname', '/fixtures/jquery.html')
+      })
 
-      return it("search", function() {
-        return this.eq("search", "?foo=bar");
-      });
-    });
+      it('port', function () {
+        this.eq('port', '3500')
+      })
 
-    describe(".log", function() {
-      beforeEach(function() {
-        cy.stub(Cypress, "getEmissions").returns([]);
+      it('protocol', function () {
+        this.eq('protocol', 'http:')
+      })
 
-        this.logs = [];
+      it('search', function () {
+        this.eq('search', '?foo=bar')
+      })
+    })
 
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "visit") {
-            this.lastLog = log;
+    describe('.log', () => {
+      beforeEach(function () {
+        cy.stub(Cypress, 'getEmissions').returns([])
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'visit') {
+            this.lastLog = log
           }
 
-          return this.logs.push(log);
-        });
+          this.logs.push(log)
+        })
 
-        return null;
-      });
+        return null
+      })
+
+      it('preserves url on subsequent visits', () => {
+        cy.visit('/fixtures/jquery.html').get('button').then(function () {
+          expect(this.lastLog.get('url')).to.eq('http://localhost:3500/fixtures/jquery.html')
+        })
+      })
+
+      it('does not log \'Page Load\' events', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .visit('/fixtures/jquery.html')
+        .then(function () {
+          this.logs.slice(0).forEach((log) => {
+            expect(log.get('name')).not.eq('page load')
+          })
+        })
+      })
 
-      it("preserves url on subsequent visits", () => cy.visit("/fixtures/jquery.html").get("button").then(function() {
-        return expect(this.lastLog.get("url")).to.eq("http://localhost:3500/fixtures/jquery.html");
-      }));
+      it('logs immediately before resolving', () => {
+        let expected = false
 
-      it("does not log 'Page Load' events", () => cy
-        .visit("/fixtures/generic.html")
-        .visit("/fixtures/jquery.html")
-        .then(function() {
-          return this.logs.slice(0).forEach(log => expect(log.get("name")).not.eq('page load'));
-      }));
+        cy.on('log:added', (attrs, log) => {
+          cy.removeAllListeners('log:added')
 
-      it("logs immediately before resolving", function() {
-        let expected = false;
+          expect(log.pick('name', 'message')).to.deep.eq({
+            name: 'visit',
+            message: 'localhost:3500/fixtures/jquery.html#/hash',
+          })
 
-        cy.on("log:added", function(attrs, log) {
-          cy.removeAllListeners("log:added");
+          expected = true
+        })
 
-          expect(log.pick("name", "message")).to.deep.eq({
-            name: "visit",
-            message: "localhost:3500/fixtures/jquery.html#/hash"
-          });
+        cy.visit('localhost:3500/fixtures/jquery.html#/hash').then(() => {
+          expect(expected).to.be.true
+        })
+      })
 
-          return expected = true;
-        });
+      it('logs obj once complete', () => {
+        cy.visit('http://localhost:3500/fixtures/generic.html').then(function () {
+          const obj = {
+            state: 'passed',
+            name: 'visit',
+            message: 'http://localhost:3500/fixtures/generic.html',
+            url: 'http://localhost:3500/fixtures/generic.html',
+          }
 
-        return cy.visit("localhost:3500/fixtures/jquery.html#/hash").then(() => expect(expected).to.be.true);
-      });
+          const { lastLog } = this
 
-      it("logs obj once complete", () => cy.visit("http://localhost:3500/fixtures/generic.html").then(function() {
-        const obj = {
-          state: "passed",
-          name: "visit",
-          message: "http://localhost:3500/fixtures/generic.html",
-          url: "http://localhost:3500/fixtures/generic.html"
-        };
-
-        const {
-          lastLog
-        } = this;
-
-        return _.each(obj, (value, key) => {
-          return expect(lastLog.get(key)).deep.eq(value, `expected key: ${key} to eq value: ${value}`);
-        });
-      }));
-
-      it("logs obj once complete when onLoad is not called", function() {
-        cy.visit("http://localhost:3500/fixtures/generic.html#foo");
-        return cy.visit("http://localhost:3500/fixtures/generic.html#foo").then(function() {
+          _.each(obj, (value, key) => {
+            expect(lastLog.get(key)).deep.eq(value, `expected key: ${key} to eq value: ${value}`)
+          })
+        })
+      })
+
+      it('logs obj once complete when onLoad is not called', () => {
+        cy.visit('http://localhost:3500/fixtures/generic.html#foo')
+
+        cy.visit('http://localhost:3500/fixtures/generic.html#foo').then(function () {
           const obj = {
-            state: "passed",
-            name: "visit",
-            message: "http://localhost:3500/fixtures/generic.html#foo",
-            url: "http://localhost:3500/fixtures/generic.html#foo"
-          };
-
-          const {
-            lastLog
-          } = this;
-
-          return _.each(obj, (value, key) => {
-            return expect(lastLog.get(key)).deep.eq(value, `expected key: ${key} to eq value: ${value}`);
-          });
-        });
-      });
+            state: 'passed',
+            name: 'visit',
+            message: 'http://localhost:3500/fixtures/generic.html#foo',
+            url: 'http://localhost:3500/fixtures/generic.html#foo',
+          }
 
-      it("snapshots once", () => cy.visit("/fixtures/generic.html").then(function() {
-        const {
-          lastLog
-        } = this;
+          const { lastLog } = this
 
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      }));
+          _.each(obj, (value, key) => {
+            expect(lastLog.get(key)).deep.eq(value, `expected key: ${key} to eq value: ${value}`)
+          })
+        })
+      })
 
-      it("can turn off logging", () => cy.visit("/timeout?ms=0", {log: false}).then(function() {
-        return expect(this.lastLog).not.to.exist;
-      }));
+      it('snapshots once', () => {
+        cy.visit('/fixtures/generic.html').then(function () {
+          const { lastLog } = this
 
-      it("displays file attributes as consoleProps", function() {
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
+
+      it('can turn off logging', () => {
+        cy.visit('/timeout?ms=0', { log: false }).then(function () {
+          expect(this.lastLog).not.to.exist
+        })
+      })
+
+      it('displays file attributes as consoleProps', () => {
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          contentType: "text/html",
-          url: "http://localhost:3500/foo/bar",
-          filePath: "/path/to/foo/bar",
+          contentType: 'text/html',
+          url: 'http://localhost:3500/foo/bar',
+          filePath: '/path/to/foo/bar',
           redirects: [1, 2],
-          cookies: [{}, {}]
-        });
-
-        return cy.visit("/fixtures/jquery.html").then(function() {
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-            "Command": "visit",
-            "File Served": "/path/to/foo/bar",
-            "Resolved Url": "http://localhost:3500/foo/bar",
-            "Redirects": [1, 2],
-            "Cookies Set": [{}, {}]
-          });
-        });
-      });
+          cookies: [{}, {}],
+        })
+
+        cy.visit('/fixtures/jquery.html').then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            'Command': 'visit',
+            'File Served': '/path/to/foo/bar',
+            'Resolved Url': 'http://localhost:3500/foo/bar',
+            'Redirects': [1, 2],
+            'Cookies Set': [{}, {}],
+          })
+        })
+      })
 
-      it("displays http attributes as consoleProps", function() {
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+      it('displays http attributes as consoleProps', () => {
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          contentType: "text/html",
-          url: "http://localhost:3500/foo",
-          originalUrl: "http://localhost:3500/foo",
+          contentType: 'text/html',
+          url: 'http://localhost:3500/foo',
+          originalUrl: 'http://localhost:3500/foo',
           redirects: [1, 2],
-          cookies: [{}, {}]
-        });
-
-        return cy.visit("http://localhost:3500/foo").then(function() {
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-            "Command": "visit",
-            "Resolved Url": "http://localhost:3500/foo",
-            "Redirects": [1, 2],
-            "Cookies Set": [{}, {}]
-          });
-        });
-      });
+          cookies: [{}, {}],
+        })
+
+        cy.visit('http://localhost:3500/foo').then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            'Command': 'visit',
+            'Resolved Url': 'http://localhost:3500/foo',
+            'Redirects': [1, 2],
+            'Cookies Set': [{}, {}],
+          })
+        })
+      })
 
-      it("displays originalUrl http attributes as consoleProps", function() {
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+      it('displays originalUrl http attributes as consoleProps', () => {
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          contentType: "text/html",
-          url: "http://localhost:3500/foo/bar",
-          originalUrl: "http://localhost:3500/foo",
+          contentType: 'text/html',
+          url: 'http://localhost:3500/foo/bar',
+          originalUrl: 'http://localhost:3500/foo',
           redirects: [1, 2],
-          cookies: [{}, {}]
-        });
-
-        return cy.visit("http://localhost:3500/foo").then(function() {
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-            "Command": "visit",
-            "Original Url": "http://localhost:3500/foo",
-            "Resolved Url": "http://localhost:3500/foo/bar",
-            "Redirects": [1, 2],
-            "Cookies Set": [{}, {}]
-          });
-        });
-      });
+          cookies: [{}, {}],
+        })
+
+        cy.visit('http://localhost:3500/foo').then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            'Command': 'visit',
+            'Original Url': 'http://localhost:3500/foo',
+            'Resolved Url': 'http://localhost:3500/foo/bar',
+            'Redirects': [1, 2],
+            'Cookies Set': [{}, {}],
+          })
+        })
+      })
 
-      it("indicates redirects in the message", function() {
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+      it('indicates redirects in the message', () => {
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          contentType: "text/html",
-          url: "http://localhost:3500/foo/bar",
-          originalUrl: "http://localhost:3500/foo",
+          contentType: 'text/html',
+          url: 'http://localhost:3500/foo/bar',
+          originalUrl: 'http://localhost:3500/foo',
           redirects: [1, 2],
-          cookies: [{}, {}]
-        });
-
-        return cy.visit("http://localhost:3500/foo").then(function() {
-          const {
-            lastLog
-          } = this;
-
-          return expect(lastLog.get("message")).to.eq(
-            "http://localhost:3500/foo -> 1 -> 2"
-          );
-        });
-      });
+          cookies: [{}, {}],
+        })
 
-      it("indicates POST in the message", () => cy.visit("http://localhost:3500/post-only", {
-        method: "POST"
-      }).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("message")).to.eq(
-          "POST http://localhost:3500/post-only"
-        );
-      }));
-
-      it("displays note in consoleProps when visiting the same page with a hash", () => cy.visit("http://localhost:3500/fixtures/generic.html#foo")
-        .visit("http://localhost:3500/fixtures/generic.html#foo")
-        .then(function() {
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-            "Command": "visit",
-            "Note": "Because this visit was to the same hash, the page did not reload and the onBeforeLoad and onLoad callbacks did not fire."
-        });
-      }));
-
-      it("logs options if they are supplied", () => cy.visit({
-        url: "http://localhost:3500/fixtures/generic.html",
-        headers: {
-          "foo": "bar"
-        },
-        notReal: "baz"
+        cy.visit('http://localhost:3500/foo').then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('message')).to.eq(
+            'http://localhost:3500/foo -> 1 -> 2',
+          )
+        })
+      })
+
+      it('indicates POST in the message', () => {
+        cy.visit('http://localhost:3500/post-only', {
+          method: 'POST',
+        }).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('message')).to.eq(
+            'POST http://localhost:3500/post-only',
+          )
+        })
+      })
+
+      it('displays note in consoleProps when visiting the same page with a hash', () => {
+        cy.visit('http://localhost:3500/fixtures/generic.html#foo')
+        .visit('http://localhost:3500/fixtures/generic.html#foo')
+        .then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            'Command': 'visit',
+            'Note': 'Because this visit was to the same hash, the page did not reload and the onBeforeLoad and onLoad callbacks did not fire.',
+          })
+        })
+      })
+
+      it('logs options if they are supplied', () => {
+        cy.visit({
+          url: 'http://localhost:3500/fixtures/generic.html',
+          headers: {
+            'foo': 'bar',
+          },
+          notReal: 'baz',
+        })
+        .then(function () {
+          expect(this.lastLog.invoke('consoleProps')['Options']).to.deep.eq({
+            url: 'http://localhost:3500/fixtures/generic.html',
+            headers: {
+              'foo': 'bar',
+            },
+          })
+        })
+      })
+
+      it('does not log options if they are not supplied', () => {
+        cy.visit('http://localhost:3500/fixtures/generic.html')
+        .then(function () {
+          expect(this.lastLog.invoke('consoleProps')['Options']).to.be.undefined
+        })
+      })
+    })
+
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'visit') {
+            this.lastLog = log
+            this.logs.push(log)
+          }
+        })
+
+        return null
+      })
+
+      it('sets error command state', function (done) {
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
+        .rejects(new Error)
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
+
+        cy.visit('/fixtures/generic.html')
+      })
+
+      it('logs once on error', function (done) {
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
+        .rejects(new Error)
+
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+
+          done()
+        })
+
+        cy.visit('/fixtures/generic.html')
+      })
+
+      it('logs once on timeout error', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.include('Your page did not fire its `load` event within `20ms`.')
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
+
+        cy.visit('/timeout?ms=5000', { timeout: 20 })
+      })
+
+      it('cancels resolve url promise on timeout', (done) => {
+        cy.on('collect:run:state', () => {
+          done(new Error('should not have tried to swap domains'))
+        })
+
+        const fn = () => {
+          // resolve after 100ms
+          return Promise.delay(100)
+          .then(() => {
+            done(new Error('should not have invoked this callback'))
+          })
+        }
+
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
+        .callsFake(fn)
+
+        cy.on('fail', () => {
+          done()
+        })
+
+        cy.visit('/', { timeout: 20 })
       })
-      .then(function() {
-        return expect(this.lastLog.invoke("consoleProps")["Options"]).to.deep.eq({
-          url: "http://localhost:3500/fixtures/generic.html",
-          headers: {
-            "foo": "bar"
-          }
-        });
-      }));
 
-      return it("does not log options if they are not supplied", () => cy.visit("http://localhost:3500/fixtures/generic.html")
-      .then(function() {
-        return expect(this.lastLog.invoke("consoleProps")["Options"]).to.be.undefined;
-      }));
-    });
+      it('throws when url isnt a string', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.visit()` must be called with a `url` or an `options` object containing a `url` as its 1st argument')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/visit')
 
-    return describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 50);
+          done()
+        })
 
-        this.logs = [];
+        cy.visit()
+      })
 
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "visit") {
-            this.lastLog = log;
-            return this.logs.push(log);
-          }
-        });
+      it('throws when url is specified twice', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.visit()` must be called with only one `url`. You specified two urls')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/visit')
 
-        return null;
-      });
+          done()
+        })
 
-      it("sets error command state", function(done) {
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
-        .rejects(new Error);
+        cy.visit('http://foobarbaz', {
+          url: 'http://foobarbaz',
+        })
+      })
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+      it('throws when method is unsupported', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.visit()` was called with an invalid method: `FOO`')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/visit')
 
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+          done()
+        })
 
-        return cy.visit("/fixtures/generic.html");
-      });
+        cy.visit({
+          url: 'http://foobarbaz',
+          method: 'FOO',
+        })
+      })
 
-      it("logs once on error", function(done) {
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
-        .rejects(new Error);
+      it('throws when headers is not an object', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.visit()` requires the `headers` option to be an object')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/visit')
 
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          return done();
-        });
+          done()
+        })
 
-        return cy.visit("/fixtures/generic.html");
+        cy.visit({
+          url: 'http://foobarbaz',
+          headers: 'quux',
+        })
       });
 
-      it("logs once on timeout error", function(done) {
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+      [
+        'foo',
+        null,
+        false,
+      ].forEach((qs) => {
+        const str = String(qs)
 
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.include("Your page did not fire its `load` event within `20ms`.");
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+        it(`throws when qs is ${str}`, (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.contain(`\`cy.visit()\` requires the \`qs\` option to be an object, but received: \`${str}\``)
 
-        return cy.visit("/timeout?ms=5000", {timeout: 20});
-      });
+            done()
+          })
 
-      it("cancels resolve url promise on timeout", function(done) {
-        cy.on("collect:run:state", () => done(new Error("should not have tried to swap domains")));
+          cy.visit({
+            url: 'http://foobarbaz',
+            qs,
+          })
+        })
+      })
 
-        const fn = () => //# resolve after 100ms
-        Promise.delay(100)
-        .then(() => done(new Error("should not have invoked this callback")));
+      it('throws when failOnStatusCode is false and retryOnStatusCodeFailure is true', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('These options are incompatible with each other.')
 
-        const p = cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
-        .callsFake(fn);
+          done()
+        })
 
-        cy.on("fail", () => done());
+        cy.visit({
+          url: 'http://foobarbaz',
+          failOnStatusCode: false,
+          retryOnStatusCodeFailure: true,
+        })
+      })
 
-        return cy.visit("/", {timeout: 20});
-      });
+      it('throws when attempting to visit a 2nd domain on different port', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      it("throws when url isnt a string", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.visit()` must be called with a `url` or an `options` object containing a `url` as its 1st argument");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/visit");
-          return done();
-        });
+          expect(err.message).to.include('`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.')
+          expect(err.message).to.include('The new URL is considered a different origin because the following parts of the URL are different:')
+          expect(err.message).to.include('> port')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/cannot-visit-different-origin-domain')
+          expect(this.logs.length).to.eq(2)
+          expect(lastLog.get('error')).to.eq(err)
 
-        return cy.visit();
-      });
+          done()
+        })
 
-      it("throws when url is specified twice", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.contain("`cy.visit()` must be called with only one `url`. You specified two urls");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/visit");
-          return done();
-        });
+        cy.visit('http://localhost:3500/fixtures/generic.html')
 
-        return cy.visit("http://foobarbaz", {
-          url: "http://foobarbaz"
-        });
-      });
+        cy.visit('http://localhost:3501/fixtures/generic.html')
+      })
 
-      it("throws when method is unsupported", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.contain("`cy.visit()` was called with an invalid method: `FOO`");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/visit");
-          return done();
-        });
-
-        return cy.visit({
-          url: "http://foobarbaz",
-          method: "FOO"
-        });
-      });
+      it('throws when attempting to visit a 2nd domain on different protocol', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      it("throws when headers is not an object", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.contain("`cy.visit()` requires the `headers` option to be an object");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/visit");
-          return done();
-        });
-
-        return cy.visit({
-          url: "http://foobarbaz",
-          headers: "quux"
-        });
-      });
+          expect(err.message).to.include('`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.')
+          expect(err.message).to.include('The new URL is considered a different origin because the following parts of the URL are different:')
+          expect(err.message).to.include('> protocol')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/cannot-visit-different-origin-domain')
+          expect(this.logs.length).to.eq(2)
+          expect(lastLog.get('error')).to.eq(err)
 
-      [
-        "foo",
-        null,
-        false,
-      ].forEach(qs => {
-        const str = String(qs);
-
-        return it(`throws when qs is ${str}`, function(done) {
-          cy.on("fail", function(err) {
-            expect(err.message).to.contain(`\`cy.visit()\` requires the \`qs\` option to be an object, but received: \`${str}\``);
-            return done();
-          });
-
-          return cy.visit({
-            url: "http://foobarbaz",
-            qs
-          });
-        });
-      });
+          done()
+        })
 
-      it("throws when failOnStatusCode is false and retryOnStatusCodeFailure is true", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.contain("These options are incompatible with each other.");
-          return done();
-        });
+        cy.visit('http://localhost:3500/fixtures/generic.html')
+        cy.visit('https://localhost:3500/fixtures/generic.html')
+      })
 
-        return cy.visit({
-          url: "http://foobarbaz",
-          failOnStatusCode: false,
-          retryOnStatusCodeFailure: true
-        });
-      });
+      it('throws when attempting to visit a 2nd domain on different superdomain', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      it("throws when attempting to visit a 2nd domain on different port", function(done) {
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(err.message).to.include("`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.");
-          expect(err.message).to.include("The new URL is considered a different origin because the following parts of the URL are different:");
-          expect(err.message).to.include("> port");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/cannot-visit-different-origin-domain");
-          expect(this.logs.length).to.eq(2);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
-
-        cy.visit("http://localhost:3500/fixtures/generic.html");
-        return cy.visit("http://localhost:3501/fixtures/generic.html");
-      });
+          expect(err.message).to.include('`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.')
+          expect(err.message).to.include('The new URL is considered a different origin because the following parts of the URL are different:')
+          expect(err.message).to.include('> superdomain')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/cannot-visit-different-origin-domain')
+          expect(this.logs.length).to.eq(2)
+          expect(lastLog.get('error')).to.eq(err)
 
-      it("throws when attempting to visit a 2nd domain on different protocol", function(done) {
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(err.message).to.include("`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.");
-          expect(err.message).to.include("The new URL is considered a different origin because the following parts of the URL are different:");
-          expect(err.message).to.include("> protocol");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/cannot-visit-different-origin-domain");
-          expect(this.logs.length).to.eq(2);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
-
-        cy.visit("http://localhost:3500/fixtures/generic.html");
-        return cy.visit("https://localhost:3500/fixtures/generic.html");
-      });
+          done()
+        })
 
-      it("throws when attempting to visit a 2nd domain on different superdomain", function(done) {
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(err.message).to.include("`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.");
-          expect(err.message).to.include("The new URL is considered a different origin because the following parts of the URL are different:");
-          expect(err.message).to.include("> superdomain");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/cannot-visit-different-origin-domain");
-          expect(this.logs.length).to.eq(2);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
-
-        cy.visit("http://localhost:3500/fixtures/generic.html");
-        return cy.visit("http://google.com:3500/fixtures/generic.html");
-      });
+        cy.visit('http://localhost:3500/fixtures/generic.html')
+        cy.visit('http://google.com:3500/fixtures/generic.html')
+      })
 
-      it("throws attemping to visit 2 unique ip addresses", function(done) {
-        const $autIframe = cy.state("$autIframe");
+      it('throws attemping to visit 2 unique ip addresses', function (done) {
+        const $autIframe = cy.state('$autIframe')
 
-        const load = () => $autIframe.trigger("load");
+        const load = () => {
+          return $autIframe.trigger('load')
+        }
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
         .resolves({
           isOkStatusCode: true,
           isHtml: true,
-          url: "http://127.0.0.1:3500"
-        });
-
-        //# whenever we're told to change the src
-        //# just fire the load event directly on the $autIframe
-        cy.stub(Cypress.utils, "iframeSrc").callsFake(load);
-
-        //# make it seem like we're already on http://127.0.0.1:3500
-        const one = Cypress.Location.create("http://127.0.0.1:3500/fixtures/generic.html");
-        cy.stub(Cypress.utils, "locExisting")
-        .returns(one);
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(err.message).to.include("`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/cannot-visit-different-origin-domain");
-          expect(this.logs.length).to.eq(2);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
-
-        return cy
-          .visit("http://127.0.0.1:3500/fixtures/generic.html")
-          .visit("http://126.0.0.1:3500/fixtures/generic.html");
-      });
+          url: 'http://127.0.0.1:3500',
+        })
 
-      it("does not call resolve:url when throws attemping to visit a 2nd domain", function(done) {
-        const backend = cy.spy(Cypress, "backend");
+        // whenever we're told to change the src
+        // just fire the load event directly on the $autIframe
+        cy.stub(Cypress.utils, 'iframeSrc').callsFake(load)
 
-        cy.on("fail", err => {
-          expect(backend).to.be.calledWithMatch("resolve:url", "http://localhost:3500/fixtures/generic.html");
-          expect(backend).not.to.be.calledWithMatch("resolve:url", "http://google.com:3500/fixtures/generic.html");
-          return done();
-        });
+        // make it seem like we're already on http://127.0.0.1:3500
+        const one = Cypress.Location.create('http://127.0.0.1:3500/fixtures/generic.html')
 
-        return cy
-          .visit("http://localhost:3500/fixtures/generic.html")
-          .visit("http://google.com:3500/fixtures/generic.html");
-      });
+        cy.stub(Cypress.utils, 'locExisting')
+        .returns(one)
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      it("displays loading_network_failed when _resolveUrl throws", function(done) {
-        const err1 = new Error("connect ECONNREFUSED 127.0.0.1:64646");
+          expect(err.message).to.include('`cy.visit()` failed because you are attempting to visit a URL that is of a different origin.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/cannot-visit-different-origin-domain')
+          expect(this.logs.length).to.eq(2)
+          expect(lastLog.get('error')).to.eq(err)
 
-        //# dont log else we create an endless loop!
-        const emit = cy.spy(Cypress, "emit").log(false);
+          done()
+        })
+
+        cy
+        .visit('http://127.0.0.1:3500/fixtures/generic.html')
+        .visit('http://126.0.0.1:3500/fixtures/generic.html')
+      })
+
+      it('does not call resolve:url when throws attemping to visit a 2nd domain', (done) => {
+        const backend = cy.spy(Cypress, 'backend')
 
-        const backend = cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
-        .rejects(err1);
+        cy.on('fail', (err) => {
+          expect(backend).to.be.calledWithMatch('resolve:url', 'http://localhost:3500/fixtures/generic.html')
+          expect(backend).not.to.be.calledWithMatch('resolve:url', 'http://google.com:3500/fixtures/generic.html')
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+          done()
+        })
+
+        cy
+        .visit('http://localhost:3500/fixtures/generic.html')
+        .visit('http://google.com:3500/fixtures/generic.html')
+      })
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+      it('displays loading_network_failed when _resolveUrl throws', function (done) {
+        const err1 = new Error('connect ECONNREFUSED 127.0.0.1:64646')
 
-http://localhost:3500/foo.html
+        // dont log else we create an endless loop!
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-We attempted to make an http request to this URL but the request failed without a response.
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
+        .rejects(err1)
 
-We received this error at the network level:
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-  > Error: connect ECONNREFUSED 127.0.0.1:64646
+          expect(err.message).to.include(stripIndent`\
+            \`cy.visit()\` failed trying to load:
 
-Common situations why this would fail:
-  - you don't have internet access
-  - you forgot to run / boot your web server
-  - your web server isn't accessible
-  - you have weird network configuration settings on your computer\
-`);
-          expect(err1.url).to.include("/foo.html");
-          expect(emit).to.be.calledWith("visit:failed", err1);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+            http://localhost:3500/foo.html
 
-        return cy.visit("/foo.html");
-      });
+            We attempted to make an http request to this URL but the request failed without a response.
 
-      it("displays loading_file_failed when _resolveUrl resp is not ok", function(done) {
+            We received this error at the network level:
+
+              > Error: connect ECONNREFUSED 127.0.0.1:64646
+
+            Common situations why this would fail:
+              - you don't have internet access
+              - you forgot to run / boot your web server
+              - your web server isn't accessible
+              - you have weird network configuration settings on your computer`)
+
+          expect(err1.url).to.include('/foo.html')
+          expect(emit).to.be.calledWith('visit:failed', err1)
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
+
+        cy.visit('/foo.html')
+      })
+
+      it('displays loading_file_failed when _resolveUrl resp is not ok', function (done) {
         const obj = {
           isOkStatusCode: false,
           isHtml: true,
-          contentType: "text/html",
-          originalUrl: "/foo.html",
-          filePath: "/path/to/foo.html",
+          contentType: 'text/html',
+          originalUrl: '/foo.html',
+          filePath: '/path/to/foo.html',
           status: 404,
-          statusText: "Not Found",
-          redirects: []
-        };
+          statusText: 'Not Found',
+          redirects: [],
+        }
 
-        const visitErrObj = _.clone(obj);
-        obj.url = obj.originalUrl;
+        obj.url = obj.originalUrl
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
-        .resolves(obj);
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
+        .resolves(obj)
 
-        //# dont log else we create an endless loop!
-        const emit = cy.spy(Cypress, "emit").log(false);
+        // dont log else we create an endless loop!
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+          expect(err.message).to.include(stripIndent`\
+            \`cy.visit()\` failed trying to load:
 
-/foo.html
+            /foo.html
 
-We failed looking for this file at the path:
+            We failed looking for this file at the path:
 
-/path/to/foo.html
+            /path/to/foo.html
 
-The internal Cypress web server responded with:
+            The internal Cypress web server responded with:
 
-  > 404: Not Found\
-`);
-          expect(emit).to.be.calledWithMatch("visit:failed", obj);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+              > 404: Not Found`)
 
-        return cy.visit("/foo.html");
-      });
+          expect(emit).to.be.calledWithMatch('visit:failed', obj)
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
 
-      it("displays loading_file_failed redirects when _resolveUrl resp is not ok", function(done) {
+        cy.visit('/foo.html')
+      })
+
+      it('displays loading_file_failed redirects when _resolveUrl resp is not ok', function (done) {
         const obj = {
           isOkStatusCode: false,
           isHtml: true,
-          contentType: "text/html",
-          originalUrl: "/bar",
-          filePath: "/path/to/bar/",
+          contentType: 'text/html',
+          originalUrl: '/bar',
+          filePath: '/path/to/bar/',
           status: 404,
-          statusText: "Not Found",
+          statusText: 'Not Found',
           redirects: [
-            "301: http://localhost:3500/bar/"
-          ]
-        };
+            '301: http://localhost:3500/bar/',
+          ],
+        }
 
-        const visitErrObj = _.clone(obj);
-        obj.url = obj.originalUrl;
+        obj.url = obj.originalUrl
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url")
-        .resolves(obj);
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url')
+        .resolves(obj)
 
-        //# dont log else we create an endless loop!
-        const emit = cy.spy(Cypress, "emit").log(false);
+        // dont log else we create an endless loop!
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+          expect(err.message).to.include(stripIndent`\
+            \`cy.visit()\` failed trying to load:
 
-/bar
+            /bar
 
-We failed looking for this file at the path:
+            We failed looking for this file at the path:
 
-/path/to/bar/
+            /path/to/bar/
 
-The internal Cypress web server responded with:
+            The internal Cypress web server responded with:
 
-  > 404: Not Found
+              > 404: Not Found
 
-We were redirected '1' time to:
+            We were redirected '1' time to:
 
-  - 301: http://localhost:3500/bar/\
-`);
-          expect(emit).to.be.calledWithMatch("visit:failed", obj);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+              - 301: http://localhost:3500/bar/`)
 
-        return cy.visit("/bar");
-      });
+          expect(emit).to.be.calledWithMatch('visit:failed', obj)
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
 
-      it("displays loading_http_failed when _resolveUrl resp is not ok", function(done) {
+          done()
+        })
+
+        cy.visit('/bar')
+      })
+
+      it('displays loading_http_failed when _resolveUrl resp is not ok', function (done) {
         const obj = {
           isOkStatusCode: false,
           isHtml: true,
-          contentType: "text/html",
-          originalUrl: "https://google.com/foo",
+          contentType: 'text/html',
+          originalUrl: 'https://google.com/foo',
           status: 500,
-          statusText: "Server Error",
-          redirects: []
-        };
+          statusText: 'Server Error',
+          redirects: [],
+        }
 
-        const visitErrObj = _.clone(obj);
-        obj.url = obj.originalUrl;
+        obj.url = obj.originalUrl
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url", "https://google.com/foo")
-        .resolves(obj);
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url', 'https://google.com/foo')
+        .resolves(obj)
 
-        //# dont log else we create an endless loop!
-        const emit = cy.spy(Cypress, "emit").log(false);
+        // dont log else we create an endless loop!
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+          expect(err.message).to.include(stripIndent`\
+            \`cy.visit()\` failed trying to load:
 
-https://google.com/foo
+            https://google.com/foo
 
-The response we received from your web server was:
+            The response we received from your web server was:
 
-  > 500: Server Error
+              > 500: Server Error
 
-This was considered a failure because the status code was not \`2xx\`.
+            This was considered a failure because the status code was not \`2xx\`.
 
-If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`\
-`);
-          expect(emit).to.be.calledWithMatch("visit:failed", obj);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+            If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\``)
 
-        return cy.visit("https://google.com/foo");
-      });
+          expect(emit).to.be.calledWithMatch('visit:failed', obj)
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
 
-      it("displays loading_http_failed redirects when _resolveUrl resp is not ok", function(done) {
+        cy.visit('https://google.com/foo')
+      })
+
+      it('displays loading_http_failed redirects when _resolveUrl resp is not ok', function (done) {
         const obj = {
           isOkStatusCode: false,
           isHtml: true,
-          contentType: "text/html",
-          originalUrl: "https://google.com/foo",
+          contentType: 'text/html',
+          originalUrl: 'https://google.com/foo',
           status: 401,
-          statusText: "Unauthorized",
+          statusText: 'Unauthorized',
           redirects: [
-            "302: https://google.com/bar/",
-            "301: https://gmail.com/"
-          ]
-        };
+            '302: https://google.com/bar/',
+            '301: https://gmail.com/',
+          ],
+        }
+
+        obj.url = obj.originalUrl
 
-        const visitErrObj = _.clone(obj);
-        obj.url = obj.originalUrl;
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url', 'https://google.com/foo')
+        .resolves(obj)
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url", "https://google.com/foo")
-        .resolves(obj);
+        // dont log else we create an endless loop!
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-        //# dont log else we create an endless loop!
-        const emit = cy.spy(Cypress, "emit").log(false);
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+          expect(err.message).to.include(stripIndent`\
+            \`cy.visit()\` failed trying to load:
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+            https://google.com/foo
 
-https://google.com/foo
+            The response we received from your web server was:
 
-The response we received from your web server was:
+              > 401: Unauthorized
 
-  > 401: Unauthorized
+            This was considered a failure because the status code was not \`2xx\`.
 
-This was considered a failure because the status code was not \`2xx\`.
+            This http request was redirected '2' times to:
 
-This http request was redirected '2' times to:
+              - 302: https://google.com/bar/
+              - 301: https://gmail.com/
 
-  - 302: https://google.com/bar/
-  - 301: https://gmail.com/
+            If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\``)
 
-If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`\
-`);
-          expect(emit).to.be.calledWithMatch("visit:failed", obj);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+          expect(emit).to.be.calledWithMatch('visit:failed', obj)
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
 
-        return cy.visit("https://google.com/foo");
+          done()
+        })
+
+        cy.visit('https://google.com/foo')
       });
 
-      //# https://github.com/cypress-io/cypress/issues/3101
+      // https://github.com/cypress-io/cypress/issues/3101
       [{
         contentType: 'application/json',
-        pathName: 'json-content-type'
+        pathName: 'json-content-type',
       }, {
         contentType: 'text/html; charset=utf-8,text/html',
-        pathName: 'invalid-content-type'
+        pathName: 'invalid-content-type',
       }]
-      .forEach(({contentType, pathName}) => it(`displays loading_invalid_content_type when content type is ${contentType} on http requests`, function(done) {
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+      .forEach(({ contentType, pathName }) => {
+        it(`displays loading_invalid_content_type when content type is ${contentType} on http requests`, function (done) {
+          cy.on('fail', (err) => {
+            const { lastLog } = this
+
+            expect(err.message).to.include(stripIndent`\
+              \`cy.visit()\` failed trying to load:
+
+              http://localhost:3500/${pathName}
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+              The \`content-type\` of the response we received from your web server was:
 
-http://localhost:3500/${pathName}
+                > \`${contentType}\`
 
-The \`content-type\` of the response we received from your web server was:
+              This was considered a failure because responses must have \`content-type: 'text/html'\`
 
-> \`${contentType}\`
+              However, you can likely use \`cy.request()\` instead of \`cy.visit()\`.
 
-This was considered a failure because responses must have \`content-type: 'text/html'\`
+              \`cy.request()\` will automatically get and set cookies and enable you to parse responses.`)
 
-However, you can likely use \`cy.request()\` instead of \`cy.visit()\`.
+            expect(this.logs.length).to.eq(1)
+            expect(lastLog.get('error')).to.eq(err)
 
-\`cy.request()\` will automatically get and set cookies and enable you to parse responses.\
-`);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+            done()
+          })
 
-        return cy.visit(`http://localhost:3500/${pathName}`);
-      }));
+          cy.visit(`http://localhost:3500/${pathName}`)
+        })
+      })
 
-      it("displays loading_invalid_content_type when isHtml is false on file requests", function(done) {
+      it('displays loading_invalid_content_type when isHtml is false on file requests', function (done) {
         const obj = {
           isOkStatusCode: true,
           isHtml: false,
-          filePath: "/path/to/bar/",
-          contentType: "application/json",
-          originalUrl: "https://google.com/foo",
+          filePath: '/path/to/bar/',
+          contentType: 'application/json',
+          originalUrl: 'https://google.com/foo',
           status: 200,
-          statusText: "OK"
-        };
+          statusText: 'OK',
+        }
 
-        const visitErrObj = _.clone(obj);
-        obj.url = obj.originalUrl;
+        obj.url = obj.originalUrl
 
-        cy.stub(Cypress, "backend")
-        .withArgs("resolve:url", "https://google.com/foo")
-        .resolves(obj);
+        cy.stub(Cypress, 'backend')
+        .withArgs('resolve:url', 'https://google.com/foo')
+        .resolves(obj)
 
-        //# dont log else we create an endless loop!
-        const emit = cy.spy(Cypress, "emit").log(false);
+        // dont log else we create an endless loop!
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-          expect(err.message).to.include(`\
-\`cy.visit()\` failed trying to load:
+          expect(err.message).to.include(stripIndent`\
+            \`cy.visit()\` failed trying to load:
 
-https://google.com/foo
+            https://google.com/foo
 
-The \`content-type\` of the response we received from this local file was:
+            The \`content-type\` of the response we received from this local file was:
 
-  > \`application/json\`
+              > \`application/json\`
 
-This was considered a failure because responses must have \`content-type: 'text/html'\`
+            This was considered a failure because responses must have \`content-type: 'text/html'\`
 
-However, you can likely use \`cy.request()\` instead of \`cy.visit()\`.
+            However, you can likely use \`cy.request()\` instead of \`cy.visit()\`.
 
-\`cy.request()\` will automatically get and set cookies and enable you to parse responses.\
-`);
-          expect(emit).to.be.calledWithMatch("visit:failed", obj);
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
+            \`cy.request()\` will automatically get and set cookies and enable you to parse responses.`)
 
-        return cy.visit("https://google.com/foo");
-      });
+          expect(emit).to.be.calledWithMatch('visit:failed', obj)
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
+
+        cy.visit('https://google.com/foo')
+      })
 
-      return it("displays body_circular when body is circular", function(done) {
+      it('displays body_circular when body is circular', function (done) {
         const foo = {
           bar: {
-            baz: {}
-          }
-        };
+            baz: {},
+          },
+        }
 
-        foo.bar.baz.quux = foo;
+        foo.bar.baz.quux = foo
 
         cy.visit({
-          method: "POST",
-          url: "http://foo.invalid/",
-          body: foo
-        });
-
-        return cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(err.message).to.eq(`\
-The \`body\` parameter supplied to \`cy.visit()\` contained a circular reference at the path "bar.baz.quux".
-
-\`body\` can only be a string or an object with no circular references.\
-`
-          );
-          expect(err.docsUrl).to.eq("https://on.cypress.io/visit");
-
-          return done();
-        });
-      });
-    });
-  });
+          method: 'POST',
+          url: 'http://foo.invalid/',
+          body: foo,
+        })
 
-  context("#page load", function() {
-    it("sets initial=true and then removes", function() {
-      Cookie.remove("__cypress.initial");
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      expect(Cookie.get("__cypress.initial")).to.be.undefined;
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq(stripIndent`\
+            The \`body\` parameter supplied to \`cy.visit()\` contained a circular reference at the path "bar.baz.quux".
 
-      let expected = false;
+            \`body\` can only be a string or an object with no circular references.`)
 
-      cy.on("window:before:unload", function() {
-        expected = true;
-        return expect(Cookie.get("__cypress.initial")).to.eq("true");
-      });
+          expect(err.docsUrl).to.eq('https://on.cypress.io/visit')
+
+          done()
+        })
+      })
+    })
+  })
 
-      //# this navigates us to a new page so
-      //# we should be setting the initial cookie
-      return cy
-        .visit("/fixtures/form.html")
-        .then(function() {
-          cy.once("window:unload", () => expect(cy.state("onPageLoadErr")).to.be.a("function"));
+  context('#page load', () => {
+    it('sets initial=true and then removes', () => {
+      Cookie.remove('__cypress.initial')
 
-          return null;}).get("a:first").click().then(function() {
-          const listeners = cy.listeners("window:load");
+      expect(Cookie.get('__cypress.initial')).to.be.undefined
 
-          //# everything should have unbound properly
-          expect(listeners.length).to.eq(0);
+      let expected = false
 
-          expect(expected).to.be.true;
+      cy.on('window:before:unload', () => {
+        expected = true
 
-          expect(cy.state("onPageLoadErr")).to.be.null;
+        expect(Cookie.get('__cypress.initial')).to.eq('true')
+      })
 
-          return expect(Cookie.get("__cypress.initial")).to.be.undefined;
-      });
-    });
+      // this navigates us to a new page so
+      // we should be setting the initial cookie
+      cy
+      .visit('/fixtures/form.html')
+      .then(() => {
+        cy.once('window:unload', () => {
+          expect(cy.state('onPageLoadErr')).to.be.a('function')
+        })
+
+        return null
+      })
+      .get('a:first').click().then(() => {
+        const listeners = cy.listeners('window:load')
 
-    //# TODO: broken - https://github.com/cypress-io/cypress/issues/4973 (chrome76+ and firefox)
-    it.skip("does not reset the timeout", function(done) {
-      cy.timeout(1000);
+        // everything should have unbound properly
+        expect(listeners.length).to.eq(0)
 
-      //# previously loading would reset the timeout
-      //# which could cause failures on the next test
-      //# if there was logic after a test finished running
-      return cy.window().then(win => {
-        const timeout = cy.spy(cy, "timeout");
+        expect(expected).to.be.true
 
-        //# we are unstable at this point
-        cy.on("window:before:unload", () => cy.whenStable(function() {
-          expect(timeout).not.to.be.called;
-          return done();
-        }));
+        expect(cy.state('onPageLoadErr')).to.be.null
 
-        return win.location.href = "about:blank";
-      });
-    });
+        expect(Cookie.get('__cypress.initial')).to.be.undefined
+      })
+    })
+
+    // TODO: broken - https://github.com/cypress-io/cypress/issues/4973 (chrome76+ and firefox)
+    it.skip('does not reset the timeout', (done) => {
+      cy.timeout(1000)
+
+      // previously loading would reset the timeout
+      // which could cause failures on the next test
+      // if there was logic after a test finished running
+      cy.window().then((win) => {
+        const timeout = cy.spy(cy, 'timeout')
+
+        // we are unstable at this point
+        cy.on('window:before:unload', () => {
+          cy.whenStable(() => {
+            expect(timeout).not.to.be.called
+
+            done()
+          })
+        })
+
+        win.location.href = 'about:blank'
+      })
+    })
 
-    it("does not time out current commands until stability is reached", function() {
-      //# on the first retry cause a page load event synchronously
-      cy.on("command:retry", function(options) {
+    it('does not time out current commands until stability is reached', () => {
+      // on the first retry cause a page load event synchronously
+      cy.on('command:retry', (options) => {
         switch (options._retries) {
-          case 1:
-            var win = cy.state("window");
-
-            //# load a page which times out after 500ms
-            //# to guarantee that url does not time out
-            var $a = win.$("<a href='/timeout?ms=500'>jquery</a>")
-            .appendTo(win.document.body);
-
-            return causeSynchronousBeforeUnload($a);
-
-          case 2:
-            //# on 2nd retry add the DOM element
-            win = cy.state("window");
-            return $("<div id='does-not-exist'>does not exist<div>")
-            .appendTo(win.document.body);
-
-          case 3:
-            //# and on the 3rd retry add the class
-            win = cy.state("window");
-            return $("#does-not-exist").addClass("foo");
+          case 1: {
+            const win = cy.state('window')
+
+            // load a page which times out after 500ms
+            // to guarantee that url does not time out
+            const $a = win.$('<a href=\'/timeout?ms=500\'>jquery</a>')
+            .appendTo(win.document.body)
+
+            causeSynchronousBeforeUnload($a)
+
+            break
+          }
+          case 2: {
+            // on 2nd retry add the DOM element
+            const win = cy.state('window')
+
+            $('<div id=\'does-not-exist\'>does not exist<div>')
+            .appendTo(win.document.body)
+
+            break
+          }
+          case 3: {
+            // and on the 3rd retry add the class
+            cy.state('window')
+
+            $('#does-not-exist').addClass('foo')
+
+            break
+          }
+          default:
+            return
         }
-      });
+      })
 
-      return cy
-        .visit("/fixtures/jquery.html")
+      cy
+      .visit('/fixtures/jquery.html')
 
-        //# make get timeout after 300ms
-        //# but even though our page does not load for 500ms
-        //# this does not time out
-        .get("#does-not-exist", { timeout: 300 }).should("have.class", "foo");
-    });
+      // make get timeout after 300ms
+      // but even though our page does not load for 500ms
+      // this does not time out
+      .get('#does-not-exist', { timeout: 300 }).should('have.class', 'foo')
+    })
 
-    return describe("errors", function() {
-      beforeEach(function() {
-        this.logs = [];
+    describe('errors', () => {
+      beforeEach(function () {
+        this.logs = []
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
 
-        return null;
-      });
+        return null
+      })
 
-      it("can time out", function(done) {
-        let thenCalled = false;
+      it('can time out', function (done) {
+        let thenCalled = false
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-          //# visit, window, page loading
-          expect(this.logs.length).to.eq(3);
-          expect(err.message).to.include("Your page did not fire its `load` event within `50ms`.");
-          expect(lastLog.get("name")).to.eq("page load");
-          expect(lastLog.get("error")).to.eq(err);
+          // visit, window, page loading
+          expect(this.logs.length).to.eq(3)
+          expect(err.message).to.include('Your page did not fire its `load` event within `50ms`.')
+          expect(lastLog.get('name')).to.eq('page load')
+          expect(lastLog.get('error')).to.eq(err)
 
           return Promise
           .delay(100)
-          .then(function() {
-            expect(cy.state("onPageLoadErr")).to.be.null;
-            expect(cy.isStopped()).to.be.true; //# make sure we ran our cleanup routine
-            expect(thenCalled).to.be.false;
+          .then(() => {
+            expect(cy.state('onPageLoadErr')).to.be.null
+            expect(cy.isStopped()).to.be.true // make sure we ran our cleanup routine
+            expect(thenCalled).to.be.false
 
-            return done();
-          });
-        });
+            done()
+          })
+        })
 
-        return cy
-          .visit("/fixtures/jquery.html")
-          .window().then(function(win) {
-            Cypress.config("pageLoadTimeout", 50);
+        cy
+        .visit('/fixtures/jquery.html')
+        .window().then((win) => {
+          Cypress.config('pageLoadTimeout', 50)
 
-            const $a = win.$("<a href='/timeout?ms=500'>jquery</a>")
-            .appendTo(win.document.body);
+          const $a = win.$('<a href=\'/timeout?ms=500\'>jquery</a>')
+          .appendTo(win.document.body)
 
-            causeSynchronousBeforeUnload($a);
+          causeSynchronousBeforeUnload($a)
 
-            return null;}).wrap(null).then(() => thenCalled = true);
-      });
+          return null
+        }).wrap(null).then(() => {
+          thenCalled = true
+        })
+      })
 
-      it("does time out once stability is reached", function(done) {
-        const logByName = name => {
-          return _.find(this.logs, log => log.get("name") === name);
-        };
+      it('does time out once stability is reached', function (done) {
+        const logByName = (name) => {
+          return _.find(this.logs, (log) => {
+            return log.get('name') === name
+          })
+        }
 
-        cy.on("fail", function(err) {
-          cy.on("command:retry", function() {
-            throw new Error("should not have retried twice");
-          });
+        cy.on('fail', (err) => {
+          cy.on('command:retry', () => {
+            throw new Error('should not have retried twice')
+          })
 
-          expect(err.message).to.include("Expected to find element");
+          expect(err.message).to.include('Expected to find element')
 
-          const get = logByName("get");
+          const get = logByName('get')
 
-          expect(get.get("error")).to.eq(err);
+          expect(get.get('error')).to.eq(err)
 
           return Promise.delay(200)
-          .then(function() {
-            expect(cy.isStopped()).to.be.true;
+          .then(() => {
+            expect(cy.isStopped()).to.be.true
 
-            return done();
-          });
-        });
+            done()
+          })
+        })
 
-        let start = null;
+        let start = null
 
-        //# on the first retry cause a page load event synchronously
-        cy.on("command:retry", function(options) {
+        // on the first retry cause a page load event synchronously
+        cy.on('command:retry', (options) => {
           switch (options._retries) {
-            case 1:
-              //# hold a ref to this
-              start = options._start;
-
-              var win = cy.state("window");
-
-              //# load a page which times out after 400ms
-              //# to guarantee that url does not time out
-              var $a = win.$("<a href='/timeout?ms=400'>jquery</a>")
-              .appendTo(win.document.body);
+            case 1: {
+              // hold a ref to this
+              start = options._start
+
+              const win = cy.state('window')
+
+              // load a page which times out after 400ms
+              // to guarantee that url does not time out
+              const $a = win.$('<a href=\'/timeout?ms=400\'>jquery</a>')
+              .appendTo(win.document.body)
+
+              causeSynchronousBeforeUnload($a)
+
+              // immediately logs pending state
+              expect(logByName('page load').get('state')).to.eq('pending')
+            }
+              break
+            case 2: {
+              // it should have reset this because we became
+              // unstable
+              expect(start).not.to.eq(options._start)
+
+              // and by the time we retry for the 2nd time
+              // the page should be loaded
+              expect(logByName('page load').get('state')).to.eq('passed')
+            }
+              break
+            default:
+              return
+          }
+        })
 
-              causeSynchronousBeforeUnload($a);
+        cy
+        .visit('/fixtures/jquery.html')
 
-              //# immediately logs pending state
-              return expect(logByName("page load").get("state")).to.eq("pending");
+        // make get timeout after only 200ms
+        .get('#does-not-exist', { timeout: 200 }).should('have.class', 'foo')
+      })
 
-            case 2:
-              //# it should have reset this because we became
-              //# unstable
-              expect(start).not.to.eq(options._start);
+      it('captures cross origin failures', function (done) {
+        cy.once('fail', (err) => {
+          const { lastLog } = this
 
-              //# and by the time we retry for the 2nd time
-              //# the page should be loaded
-              return expect(logByName("page load").get("state")).to.eq("passed");
-          }
-        });
+          expect(this.logs.length).to.eq(2)
+          expect(err.message).to.include('Cypress detected a cross origin error happened on page load')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/cross-origin-violation')
+          expect(lastLog.get('name')).to.eq('page load')
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(lastLog.get('error')).to.eq(err)
+          expect(cy.state('onPageLoadErr')).to.be.null
 
-        return cy
-          .visit("/fixtures/jquery.html")
+          done()
+        })
 
-          //# make get timeout after only 200ms
-          .get("#does-not-exist", { timeout: 200 }).should("have.class", "foo");
-      });
+        cy
+        .visit('/fixtures/jquery.html')
+        .window({ log: false }).then((win) => {
+          const url = 'http://localhost:3501/fixtures/generic.html'
 
-      it("captures cross origin failures", function(done) {
-        cy.once("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(2);
-          expect(err.message).to.include("Cypress detected a cross origin error happened on page load");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/cross-origin-violation");
-          expect(lastLog.get("name")).to.eq("page load");
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(lastLog.get("error")).to.eq(err);
-          expect(cy.state("onPageLoadErr")).to.be.null;
-
-          return done();
-        });
-
-        return cy
-          .visit("/fixtures/jquery.html")
-          .window({log: false}).then(function(win) {
-            const url = "http://localhost:3501/fixtures/generic.html";
-
-            const $a = win.$(`<a href='${url}'>jquery</a>`)
-            .appendTo(win.document.body);
-
-            return causeSynchronousBeforeUnload($a);
-        });
-      });
+          const $a = win.$(`<a href='${url}'>jquery</a>`)
+          .appendTo(win.document.body)
 
-      return null;
-    });
-  });
+          causeSynchronousBeforeUnload($a)
+        })
+      })
 
-  //# this tests isLoading spinner
-  //# and page load event
-  context("#page loading", function() {
-    beforeEach(function() {
-      this.logs = [];
+      return null
+    })
+  })
 
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "page load") {
-          this.lastLog = log;
+  // this tests isLoading spinner
+  // and page load event
+  context('#page loading', () => {
+    beforeEach(function () {
+      this.logs = []
 
-          return this.logs.push(log);
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'page load') {
+          this.lastLog = log
+          this.logs.push(log)
         }
-      });
+      })
 
-      return null;
-    });
+      return null
+    })
 
-    it("emits 'page:loading' before and after initial visit", function() {
-      const emit = cy.spy(Cypress, "emit").log(false).withArgs("page:loading");
+    it('emits \'page:loading\' before and after initial visit', () => {
+      const emit = cy.spy(Cypress, 'emit').log(false).withArgs('page:loading')
 
-      return cy
-        .visit("/timeout?ms=10", {
-          onBeforeLoad() {
-            expect(emit).to.be.calledOnce;
-            return expect(emit.firstCall).to.be.calledWith("page:loading", true);
-          }
+      cy
+      .visit('/timeout?ms=10', {
+        onBeforeLoad () {
+          expect(emit).to.be.calledOnce
+          expect(emit.firstCall).to.be.calledWith('page:loading', true)
+        },
+      })
+      .then(() => {
+        expect(emit).to.be.calledTwice
+        expect(emit.secondCall).to.be.calledWith('page:loading', false)
+      })
+    })
+
+    it('emits during page navigation', () => {
+      const emit = cy.spy(Cypress, 'emit').log(false).withArgs('page:loading')
+      let expected = false
+
+      cy
+      .visit('/fixtures/generic.html')
+      .then(() => {
+        cy.once('window:unload', () => {
+          expected = true
+          expect(emit.callCount).to.eq(3)
+          expect(emit.thirdCall).to.be.calledWith('page:loading', true)
         })
-        .then(function() {
-          expect(emit).to.be.calledTwice;
-          return expect(emit.secondCall).to.be.calledWith("page:loading", false);
-      });
-    });
-
-    it("emits during page navigation", function() {
-      const emit = cy.spy(Cypress, "emit").log(false).withArgs("page:loading");
-      let expected = false;
-
-      return cy
-        .visit("/fixtures/generic.html")
-        .then(() => cy.once("window:unload", function() {
-        expected = true;
-        expect(emit.callCount).to.eq(3);
-        return expect(emit.thirdCall).to.be.calledWith("page:loading", true);
-      })).get("#dimensions").click()
-        .then(function() {
-          expect(expected).to.be.true;
-          expect(emit.callCount).to.eq(4);
-          return expect(emit.getCall(3)).to.be.calledWith("page:loading", false);
-      });
-    });
-
-    it("does not log during initial visit", () => cy.visit("/timeout?ms=10").then(function() {
-      return expect(this.lastLog).not.to.exist;
-    }));
-
-    it("logs during page navigation", function() {
-      let expected = false;
-
-      return cy
-        .visit("/fixtures/generic.html")
-        .then(function() {
-          return cy.once("window:before:unload", () => {
-            expected = true;
-
-            expect(this.lastLog).to.exist;
-            expect(this.lastLog.get("state")).to.eq("pending");
-            expect(this.lastLog.get("message")).to.eq("--waiting for new page to load--");
-            return expect(this.lastLog.get("snapshots")).to.not.exist;
-          });}).get("#dimensions").click()
-        .then(function() {
-          expect(expected).to.be.true;
-          expect(this.lastLog.get("state")).to.eq("passed");
-          expect(this.lastLog.get("message")).to.eq("--page loaded--");
-          return expect(this.lastLog.get("snapshots")).to.have.length(1);
-      });
-    });
+      }).get('#dimensions').click()
+      .then(() => {
+        expect(expected).to.be.true
+        expect(emit.callCount).to.eq(4)
+        expect(emit.getCall(3)).to.be.calledWith('page:loading', false)
+      })
+    })
+
+    it('does not log during initial visit', () => {
+      cy.visit('/timeout?ms=10').then(function () {
+        expect(this.lastLog).not.to.exist
+      })
+    })
 
-    it("logs during form submission and yields stale element", function() {
-      let expected = false;
+    it('logs during page navigation', () => {
+      let expected = false
 
-      const names = cy.queue.names();
+      cy
+      .visit('/fixtures/generic.html')
+      .then(function () {
+        cy.once('window:before:unload', () => {
+          expected = true
 
-      return cy
-        .visit("/fixtures/form.html")
-        .then(function() {
-          const $input = cy.$$("form#click-me input[type=submit]");
+          expect(this.lastLog).to.exist
+          expect(this.lastLog.get('state')).to.eq('pending')
+          expect(this.lastLog.get('message')).to.eq('--waiting for new page to load--')
+          expect(this.lastLog.get('snapshots')).to.not.exist
+        })
+      }).get('#dimensions').click()
+      .then(function () {
+        expect(expected).to.be.true
+        expect(this.lastLog.get('state')).to.eq('passed')
+        expect(this.lastLog.get('message')).to.eq('--page loaded--')
+        expect(this.lastLog.get('snapshots')).to.have.length(1)
+      })
+    })
 
-          cy.once("window:before:unload", () => {
-            expected = true;
+    it('logs during form submission and yields stale element', () => {
+      let expected = false
 
-            expect(this.lastLog).to.exist;
-            expect(this.lastLog.get("state")).to.eq("pending");
-            expect(this.lastLog.get("message")).to.eq("--waiting for new page to load--");
-            return expect(this.lastLog.get("snapshots")).to.not.exist;
-          });
+      const names = cy.queue.names()
 
-          return cy
-            .get("form#click-me")
-            .find("input[type=submit]")
-            .click()
-            .then(function(subject) {
-              expect(expected).to.be.true;
+      cy
+      .visit('/fixtures/form.html')
+      .then(function () {
+        const $input = cy.$$('form#click-me input[type=submit]')
 
-              expect(this.lastLog.get("state")).to.eq("passed");
-              expect(this.lastLog.get("message")).to.eq("--page loaded--");
-              expect(this.lastLog.get("snapshots")).to.have.length(1);
+        cy.once('window:before:unload', () => {
+          expected = true
 
-              expect(cy.queue.names()).to.deep.eq(names.concat([
-                "visit", "then", "get", "find", "click", "then"
-              ])
-              );
+          expect(this.lastLog).to.exist
+          expect(this.lastLog.get('state')).to.eq('pending')
+          expect(this.lastLog.get('message')).to.eq('--waiting for new page to load--')
+          expect(this.lastLog.get('snapshots')).to.not.exist
+        })
 
-              expect(Cypress.dom.isDetached(subject)).to.be.true;
+        cy
+        .get('form#click-me')
+        .find('input[type=submit]')
+        .click()
+        .then(function (subject) {
+          expect(expected).to.be.true
 
-              return expect(subject.get(0)).to.eq($input.get(0));
-          });
-      });
-    });
+          expect(this.lastLog.get('state')).to.eq('passed')
+          expect(this.lastLog.get('message')).to.eq('--page loaded--')
+          expect(this.lastLog.get('snapshots')).to.have.length(1)
 
-    return it("waits for stability at the end of the command queue when not stable", done => cy
-    .visit("/fixtures/generic.html")
-    .then(function(win) {
-      cy.on("window:load", () => cy.on("command:queue:end", () => done()));
+          expect(cy.queue.names()).to.deep.eq(names.concat([
+            'visit', 'then', 'get', 'find', 'click', 'then',
+          ]))
 
-      cy.on("command:queue:before:end", function() {
-        //# force us to become unstable immediately
-        //# else the beforeunload event fires at the end
-        //# of the tick which is too late
-        cy.isStable(false, "testing");
+          expect(Cypress.dom.isDetached(subject)).to.be.true
+          expect(subject.get(0)).to.eq($input.get(0))
+        })
+      })
+    })
+
+    it('waits for stability at the end of the command queue when not stable', (done) => {
+      cy
+      .visit('/fixtures/generic.html')
+      .then((win) => {
+        cy.on('window:load', () => {
+          cy.on('command:queue:end', () => {
+            done()
+          })
+        })
 
-        //# this should cause instability
-        return win.location.href = "/timeout?ms=100";
-      });
+        cy.on('command:queue:before:end', () => {
+        // force us to become unstable immediately
+        // else the beforeunload event fires at the end
+        // of the tick which is too late
+          cy.isStable(false, 'testing')
 
-      return null;
-    }));
-  });
+          win.location.href = '/timeout?ms=100'
+        })
 
-  context("#url:changed", function() {
-    beforeEach(function() {
-      this.logs = [];
+        return null
+      })
+    })
+  })
 
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "new url") {
-          this.lastLog = log;
+  context('#url:changed', () => {
+    beforeEach(function () {
+      this.logs = []
 
-          return this.logs.push(log);
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'new url') {
+          this.lastLog = log
+          this.logs.push(log)
         }
-      });
+      })
+
+      return null
+    })
+
+    describe('page navigation', () => {
+      it('emits url:changed event on initial visit', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false).withArgs('url:changed')
+
+        cy
+        .visit('/fixtures/generic.html')
+        .then(() => {
+          expect(emit).to.be.calledOnce
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/generic.html',
+          )
+        })
+      })
 
-      return null;
-    });
+      it('emits url:changed on 2nd visit to different page', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false).withArgs('url:changed')
 
-    describe("page navigation", function() {
-      it("emits url:changed event on initial visit", function() {
-        const emit = cy.spy(Cypress, "emit").log(false).withArgs("url:changed");
+        cy
+        .visit('/fixtures/generic.html')
+        .visit('/fixtures/jquery.html')
+        .then(() => {
+          expect(emit).to.be.calledTwice
 
-        return cy
-          .visit("/fixtures/generic.html")
-          .then(function() {
-            expect(emit).to.be.calledOnce;
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/generic.html',
+          )
 
-            return expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/generic.html"
-            );
-        });
-      });
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/jquery.html',
+          )
+        })
+      })
 
-      it("emits url:changed on 2nd visit to different page", function() {
-        const emit = cy.spy(Cypress, "emit").log(false).withArgs("url:changed");
-
-        return cy
-          .visit("/fixtures/generic.html")
-          .visit("/fixtures/jquery.html")
-          .then(function() {
-            expect(emit).to.be.calledTwice;
-
-            expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/generic.html"
-            );
-
-            return expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/jquery.html"
-            );
-        });
-      });
+      it('does not emit url:changed twice on visit to the same page', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false).withArgs('url:changed')
+
+        cy
+        .visit('/fixtures/generic.html')
+        .visit('/fixtures/generic.html')
+        .then(() => {
+          expect(emit).to.be.calledOnce
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/generic.html',
+          )
+        })
+      })
 
-      it("does not emit url:changed twice on visit to the same page", function() {
-        const emit = cy.spy(Cypress, "emit").log(false).withArgs("url:changed");
+      it('does not log url:changed event on visit', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .then(function () {
+          expect(this.lastLog).not.to.exist
+        })
+      })
 
-        return cy
-          .visit("/fixtures/generic.html")
-          .visit("/fixtures/generic.html")
-          .then(function() {
-            expect(emit).to.be.calledOnce;
+      it('emits url:changed event on page navigation', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false).withArgs('url:changed')
 
-            return expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/generic.html"
-            );
-        });
-      });
+        cy
+        .visit('/fixtures/generic.html')
+        .get('#dimensions').click()
+        .then(() => {
+          expect(emit).to.be.calledTwice
 
-      it("does not log url:changed event on visit", () => cy
-        .visit("/fixtures/generic.html")
-        .then(function() {
-          return expect(this.lastLog).not.to.exist;
-      }));
-
-      it("emits url:changed event on page navigation", function() {
-        const emit = cy.spy(Cypress, "emit").log(false).withArgs("url:changed");
-
-        return cy
-          .visit("/fixtures/generic.html")
-          .get("#dimensions").click()
-          .then(function() {
-            expect(emit).to.be.calledTwice;
-
-            expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/generic.html"
-            );
-
-            return expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/dimensions.html"
-            );
-        });
-      });
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/generic.html',
+          )
 
-      return it("logs url:changed event on page navigation", () => cy
-        .visit("/fixtures/generic.html")
-        .get("#dimensions").click()
-        .then(function() {
-          expect(this.logs.length).to.eq(1);
-
-          expect(this.logs[0].get("message")).to.eq(
-            "http://localhost:3500/fixtures/dimensions.html"
-          );
-
-          return expect(this.logs[0].invoke("consoleProps")).to.deep.eq({
-            "Event": "new url",
-            "New Url": "http://localhost:3500/fixtures/dimensions.html",
-            "Url Updated By": "page navigation event (before:load)"
-          });
-      }));
-    });
-
-    describe("hashchange events", function() {
-      it("emits url:changed event", function() {
-        const emit = cy.spy(Cypress, "emit").log(false);
-
-        return cy
-          .visit("/fixtures/generic.html")
-          .get("#hashchange").click()
-          .then(() => expect(emit).to.be.calledWith(
-          "url:changed",
-          "http://localhost:3500/fixtures/generic.html#hashchange"
-        ));
-      });
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/dimensions.html',
+          )
+        })
+      })
 
-      it("emits url:changed event as navigation events occur", function() {
-        const emit = cy.spy(Cypress, "emit").log(false).withArgs("url:changed");
-
-        return cy
-        .visit("/fixtures/generic.html")
-        .get("#hashchange").click()
-        .window().then(win => new Promise(function(resolve) {
-          cy.once("navigation:changed", resolve);
-
-          return win.history.back();}).then(() => new Promise(function(resolve) {
-          cy.once("navigation:changed", resolve);
-
-          return win.history.forward();
-        })).then(function() {
-          expect(emit.callCount).to.eq(4);
-
-          expect(emit.firstCall).to.be.calledWith(
-            "url:changed",
-            "http://localhost:3500/fixtures/generic.html"
-          );
-
-          expect(emit.secondCall).to.be.calledWith(
-            "url:changed",
-            "http://localhost:3500/fixtures/generic.html#hashchange"
-          );
-
-          expect(emit.thirdCall).to.be.calledWith(
-            "url:changed",
-            "http://localhost:3500/fixtures/generic.html"
-          );
-
-          return expect(emit.getCall(3)).to.be.calledWith(
-            "url:changed",
-            "http://localhost:3500/fixtures/generic.html#hashchange"
-          );
-        }));
-      });
+      it('logs url:changed event on page navigation', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .get('#dimensions').click()
+        .then(function () {
+          expect(this.logs.length).to.eq(1)
+
+          expect(this.logs[0].get('message')).to.eq(
+            'http://localhost:3500/fixtures/dimensions.html',
+          )
+
+          expect(this.logs[0].invoke('consoleProps')).to.deep.eq({
+            'Event': 'new url',
+            'New Url': 'http://localhost:3500/fixtures/dimensions.html',
+            'Url Updated By': 'page navigation event (before:load)',
+          })
+        })
+      })
+    })
+
+    describe('hashchange events', () => {
+      it('emits url:changed event', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false)
+
+        cy
+        .visit('/fixtures/generic.html')
+        .get('#hashchange').click()
+        .then(() => {
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/generic.html#hashchange',
+          )
+        })
+      })
 
-      it("logs url changed event", () => cy
-        .visit("/fixtures/generic.html")
-        .window().then(function(win) {
-          let ohc = null;
-
-          win.onhashchange = event => ohc = event;
-
-          return cy
-          .get("#hashchange").click()
-          .then(function() {
-            const {
-              lastLog
-            } = this;
-
-            expect(lastLog.get("message")).to.eq("http://localhost:3500/fixtures/generic.html#hashchange");
-            expect(lastLog.get("type")).to.eq("parent");
-            expect(lastLog.get("event")).to.be.true;
-
-            return expect(lastLog.invoke("consoleProps")).to.deep.eq({
-              "Event": "new url",
-              "New Url": "http://localhost:3500/fixtures/generic.html#hashchange",
-              "Url Updated By": "hashchange",
-              "Args": ohc
-            });
-          });
-      }));
-
-      return it("logs url:changed event as navigation events occur", () => cy
-      .visit("/fixtures/generic.html")
-      .get("#hashchange").click()
-      .window().then(win => new Promise(function(resolve) {
-        cy.once("navigation:changed", resolve);
-
-        return win.history.back();}).then(() => new Promise(function(resolve) {
-        cy.once("navigation:changed", resolve);
-
-        return win.history.forward();
-      }))).then(function() {
-        expect(this.logs.length).to.eq(3);
-
-        expect(this.logs[0].get("message")).to.eq(
-          "http://localhost:3500/fixtures/generic.html#hashchange"
-        );
-
-        expect(this.logs[1].get("message")).to.eq(
-          "http://localhost:3500/fixtures/generic.html"
-        );
-
-        return expect(this.logs[2].get("message")).to.eq(
-          "http://localhost:3500/fixtures/generic.html#hashchange"
-        );
-      }));
-    });
-
-    describe("history.pushState", function() {
-      it("emits url:changed event", function() {
-        const emit = cy.spy(Cypress, "emit").log(false);
-
-        return cy
-          .visit("/fixtures/generic.html")
-          .window().then(function(win) {
-            win.history.pushState({foo: "bar"}, null, "pushState.html");
-
-            return expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/pushState.html"
-            );
-        });
-      });
+      it('emits url:changed event as navigation events occur', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false).withArgs('url:changed')
+
+        cy
+        .visit('/fixtures/generic.html')
+        .get('#hashchange').click()
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            cy.once('navigation:changed', resolve)
+
+            win.history.back()
+          }).then(() => {
+            return new Promise((resolve) => {
+              cy.once('navigation:changed', resolve)
+
+              win.history.forward()
+            })
+          }).then(() => {
+            expect(emit.callCount).to.eq(4)
+
+            expect(emit.firstCall).to.be.calledWith(
+              'url:changed',
+              'http://localhost:3500/fixtures/generic.html',
+            )
+
+            expect(emit.secondCall).to.be.calledWith(
+              'url:changed',
+              'http://localhost:3500/fixtures/generic.html#hashchange',
+            )
+
+            expect(emit.thirdCall).to.be.calledWith(
+              'url:changed',
+              'http://localhost:3500/fixtures/generic.html',
+            )
+
+            expect(emit.getCall(3)).to.be.calledWith(
+              'url:changed',
+              'http://localhost:3500/fixtures/generic.html#hashchange',
+            )
+          })
+        })
+      })
+
+      it('logs url changed event', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .window().then((win) => {
+          let ohc = null
+
+          win.onhashchange = (event) => {
+            ohc = event
+          }
+
+          cy
+          .get('#hashchange').click()
+          .then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('message')).to.eq('http://localhost:3500/fixtures/generic.html#hashchange')
+            expect(lastLog.get('type')).to.eq('parent')
+            expect(lastLog.get('event')).to.be.true
+
+            expect(lastLog.invoke('consoleProps')).to.deep.eq({
+              'Event': 'new url',
+              'New Url': 'http://localhost:3500/fixtures/generic.html#hashchange',
+              'Url Updated By': 'hashchange',
+              'Args': ohc,
+            })
+          })
+        })
+      })
+
+      it('logs url:changed event as navigation events occur', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .get('#hashchange').click()
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            cy.once('navigation:changed', resolve)
+
+            win.history.back()
+          }).then(() => {
+            return new Promise((resolve) => {
+              cy.once('navigation:changed', resolve)
+
+              win.history.forward()
+            })
+          })
+        }).then(function () {
+          expect(this.logs.length).to.eq(3)
+
+          expect(this.logs[0].get('message')).to.eq(
+            'http://localhost:3500/fixtures/generic.html#hashchange',
+          )
+
+          expect(this.logs[1].get('message')).to.eq(
+            'http://localhost:3500/fixtures/generic.html',
+          )
+
+          expect(this.logs[2].get('message')).to.eq(
+            'http://localhost:3500/fixtures/generic.html#hashchange',
+          )
+        })
+      })
+    })
+
+    describe('history.pushState', () => {
+      it('emits url:changed event', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false)
+
+        cy
+        .visit('/fixtures/generic.html')
+        .window().then((win) => {
+          win.history.pushState({ foo: 'bar' }, null, 'pushState.html')
 
-      return it("logs url changed event", () => cy
-        .visit("/fixtures/generic.html")
-        .window().then(function(win) {
-          win.history.pushState({foo: "bar"}, null, "pushState.html");
-
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("message")).to.eq("http://localhost:3500/fixtures/pushState.html");
-          expect(lastLog.get("type")).to.eq("parent");
-          expect(lastLog.get("event")).to.be.true;
-
-          return expect(lastLog.invoke("consoleProps")).to.deep.eq({
-            "Event": "new url",
-            "New Url": "http://localhost:3500/fixtures/pushState.html",
-            "Url Updated By": "pushState",
-            "Args": [
-              { foo: "bar" },
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/pushState.html',
+          )
+        })
+      })
+
+      it('logs url changed event', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .window().then(function (win) {
+          win.history.pushState({ foo: 'bar' }, null, 'pushState.html')
+
+          const { lastLog } = this
+
+          expect(lastLog.get('message')).to.eq('http://localhost:3500/fixtures/pushState.html')
+          expect(lastLog.get('type')).to.eq('parent')
+          expect(lastLog.get('event')).to.be.true
+          expect(lastLog.invoke('consoleProps')).to.deep.eq({
+            'Event': 'new url',
+            'New Url': 'http://localhost:3500/fixtures/pushState.html',
+            'Url Updated By': 'pushState',
+            'Args': [
+              { foo: 'bar' },
               null,
-              "pushState.html",
-            ]
-          });
-      }));
-    });
-
-    return describe("history.replaceState", function() {
-      it("emits url:changed event", function() {
-        const emit = cy.spy(Cypress, "emit").log(false);
-
-        return cy
-          .visit("/fixtures/generic.html")
-          .window().then(function(win) {
-            win.history.replaceState({foo: "bar"}, null, "replaceState.html");
-
-            return expect(emit).to.be.calledWith(
-              "url:changed",
-              "http://localhost:3500/fixtures/replaceState.html"
-            );
-        });
-      });
+              'pushState.html',
+            ],
+          })
+        })
+      })
+    })
+
+    describe('history.replaceState', () => {
+      it('emits url:changed event', () => {
+        const emit = cy.spy(Cypress, 'emit').log(false)
 
-      return it("logs url changed event", () => cy
-        .visit("/fixtures/generic.html")
-        .window().then(function(win) {
-          win.history.replaceState({foo: "bar"}, null, "replaceState.html");
-
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("message")).to.eq("http://localhost:3500/fixtures/replaceState.html");
-          expect(lastLog.get("type")).to.eq("parent");
-          expect(lastLog.get("event")).to.be.true;
-
-          return expect(lastLog.invoke("consoleProps")).to.deep.eq({
-            "Event": "new url",
-            "New Url": "http://localhost:3500/fixtures/replaceState.html",
-            "Url Updated By": "replaceState",
-            "Args": [
-              { foo: "bar" },
+        cy
+        .visit('/fixtures/generic.html')
+        .window().then((win) => {
+          win.history.replaceState({ foo: 'bar' }, null, 'replaceState.html')
+
+          expect(emit).to.be.calledWith(
+            'url:changed',
+            'http://localhost:3500/fixtures/replaceState.html',
+          )
+        })
+      })
+
+      it('logs url changed event', () => {
+        cy
+        .visit('/fixtures/generic.html')
+        .window().then(function (win) {
+          win.history.replaceState({ foo: 'bar' }, null, 'replaceState.html')
+
+          const { lastLog } = this
+
+          expect(lastLog.get('message')).to.eq('http://localhost:3500/fixtures/replaceState.html')
+          expect(lastLog.get('type')).to.eq('parent')
+          expect(lastLog.get('event')).to.be.true
+          expect(lastLog.invoke('consoleProps')).to.deep.eq({
+            'Event': 'new url',
+            'New Url': 'http://localhost:3500/fixtures/replaceState.html',
+            'Url Updated By': 'replaceState',
+            'Args': [
+              { foo: 'bar' },
               null,
-              "replaceState.html",
-            ]
-          });
-      }));
-    });
-  });
-
-  return context("#form sub", function() {
-    beforeEach(function() {
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "form sub") {
-          this.lastLog = log;
-
-          return this.logs.push(log);
+              'replaceState.html',
+            ],
+          })
+        })
+      })
+    })
+  })
+
+  context('#form sub', () => {
+    beforeEach(function () {
+      this.logs = []
+
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'form sub') {
+          this.lastLog = log
+          this.logs.push(log)
         }
-      });
+      })
 
-      return null;
-    });
+      return null
+    })
 
-    return it("logs 'form sub'", function() {
-      let event = null;
+    it('logs \'form sub\'', () => {
+      let event = null
 
-      return cy
-        .visit("/fixtures/form.html")
-        .then(function() {
-          const $form = cy.$$("#click-me").on("submit", e => event = e.originalEvent);
+      cy
+      .visit('/fixtures/form.html')
+      .then(() => {
+        const $form = cy.$$('#click-me').on('submit', (e) => {
+          event = e.originalEvent
+        })
 
-          return cy
-          .get("#click-me").find("input[type=submit]").click()
-          .then(function() {
-            expect(this.logs.length).to.eq(1);
+        cy
+        .get('#click-me').find('input[type=submit]').click()
+        .then(function () {
+          expect(this.logs.length).to.eq(1)
 
-            expect(this.logs[0].get("message")).to.eq(
-              "--submitting form--"
-            );
+          expect(this.logs[0].get('message')).to.eq(
+            '--submitting form--',
+          )
 
-            return expect(this.logs[0].invoke("consoleProps")).to.deep.eq({
-              "Event": "form sub",
-              "Originated From": $form.get(0),
-              "Args": event
-            });
-          });
-      });
-    });
-  });
-});
+          expect(this.logs[0].invoke('consoleProps')).to.deep.eq({
+            'Event': 'form sub',
+            'Originated From': $form.get(0),
+            'Args': event,
+          })
+        })
+      })
+    })
+  })
+})
 
+const causeSynchronousBeforeUnload = function ($a) {
+  // this causes a synchronous beforeunload event
+  // chrome & firefox behave differently
+  const win = $a[0].ownerDocument.defaultView
 
-var causeSynchronousBeforeUnload = function($a) {
-  //# this causes a synchronous beforeunload event
-  //# chrome & firefox behave differently
-  const win = $a[0].ownerDocument.defaultView;
   if (Cypress.isBrowser('firefox')) {
-    return win.location.href = $a[0].href;
-  } else { return $a.get(0).click(); }
-};
+    win.location.href = $a[0].href
+  } else {
+    return $a.get(0).click()
+  }
+}
diff --git a/packages/driver/test/cypress/integration/commands/popups_spec.js b/packages/driver/test/cypress/integration/commands/popups_spec.js
index c30198df11e2..584d309d298d 100644
--- a/packages/driver/test/cypress/integration/commands/popups_spec.js
+++ b/packages/driver/test/cypress/integration/commands/popups_spec.js
@@ -1,88 +1,96 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-describe("src/cy/commands/popups", function() {
-  context("alert", function() {
-    beforeEach(function() {
-      cy.visit("/fixtures/generic.html");
-
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "alert") {
-          return this.logs.push(log);
-        }
-      });
-
-      return null;
-    });
-
-    return it("logs the alert", () => cy.window().then(win => win.alert("fooooo")).then(function() {
-      expect(this.logs.length).to.eq(1);
-      expect(this.logs[0].get("name")).to.eq("alert");
-      expect(this.logs[0].get("message")).to.eq("fooooo");
-
-      const consoleProps = this.logs[0].invoke("consoleProps");
-
-      return expect(consoleProps).to.deep.eq({
-        Event: "alert",
-        Alerted: "fooooo"
-      });
-    }));
-  });
-
-  return context("confirm", function() {
-    beforeEach(function() {
-      cy.visit("/fixtures/generic.html");
+describe('src/cy/commands/popups', () => {
+  context('alert', () => {
+    beforeEach(function () {
+      cy.visit('/fixtures/generic.html')
 
-      this.logs = [];
+      this.logs = []
 
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "confirm") {
-          return this.logs.push(log);
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'alert') {
+          this.logs.push(log)
         }
-      });
+      })
+
+      return null
+    })
+
+    it('logs the alert', () => {
+      cy.window().then((win) => {
+        win.alert('fooooo')
+      })
+      .then(function () {
+        expect(this.logs.length).to.eq(1)
+        expect(this.logs[0].get('name')).to.eq('alert')
+        expect(this.logs[0].get('message')).to.eq('fooooo')
+
+        const consoleProps = this.logs[0].invoke('consoleProps')
+
+        expect(consoleProps).to.deep.eq({
+          Event: 'alert',
+          Alerted: 'fooooo',
+        })
+      })
+    })
+  })
+
+  context('confirm', () => {
+    beforeEach(function () {
+      cy.visit('/fixtures/generic.html')
+
+      this.logs = []
+
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'confirm') {
+          this.logs.push(log)
+        }
+      })
+
+      return null
+    })
+
+    it('logs the confirm', () => {
+      cy.window().then((win) => {
+        win.confirm('Delete hard drive?')
+      }).then(function () {
+        expect(this.logs.length).to.eq(1)
+        expect(this.logs[0].get('name')).to.eq('confirm')
+        expect(this.logs[0].get('message')).to.eq('Delete hard drive?')
+
+        const consoleProps = this.logs[0].invoke('consoleProps')
+
+        expect(consoleProps).to.deep.eq({
+          Event: 'confirm',
+          Prompted: 'Delete hard drive?',
+          Confirmed: true,
+        })
+      })
+    })
+
+    it('can turn on and off confirmation', () => {
+      cy.on('window:confirm', (str) => {
+        switch (str) {
+          case 'foo': return false
+          case 'bar': return true
+          case 'baz': return undefined
+          default: return
+        }
+      })
 
-      return null;
-    });
+      cy.window().then((win) => {
+        const confirmedFoo = win.confirm('foo')
 
-    it("logs the confirm", () => cy.window().then(win => win.confirm("Delete hard drive?")).then(function() {
-      expect(this.logs.length).to.eq(1);
-      expect(this.logs[0].get("name")).to.eq("confirm");
-      expect(this.logs[0].get("message")).to.eq("Delete hard drive?");
+        expect(confirmedFoo).to.be.false
 
-      const consoleProps = this.logs[0].invoke("consoleProps");
+        const confirmedBar = win.confirm('bar')
 
-      return expect(consoleProps).to.deep.eq({
-        Event: "confirm",
-        Prompted: "Delete hard drive?",
-        Confirmed: true
-      });
-    }));
+        expect(confirmedBar).to.be.true
 
-    return it("can turn on and off confirmation", function() {
-      cy.on("window:confirm", function(str) {
-        switch (str) {
-          case "foo": return false;
-          case "bar": return true;
-          case "baz": return undefined;
-        }
-      });
-
-      return cy.window().then(function(win) {
-        const confirmedFoo = win.confirm("foo");
-        expect(confirmedFoo).to.be.false;
-
-        const confirmedBar = win.confirm("bar");
-        expect(confirmedBar).to.be.true;
-
-        //# undefined is not strictly false
-        //# so the confirmation should be true
-        const confirmedBaz = win.confirm("baz");
-        return expect(confirmedBaz).to.be.true;
-      });
-    });
-  });
-});
+        // undefined is not strictly false
+        // so the confirmation should be true
+        const confirmedBaz = win.confirm('baz')
+
+        expect(confirmedBaz).to.be.true
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/request_spec.js b/packages/driver/test/cypress/integration/commands/request_spec.js
index 0bd27bef4f32..5cfa8a9f00f0 100644
--- a/packages/driver/test/cypress/integration/commands/request_spec.js
+++ b/packages/driver/test/cypress/integration/commands/request_spec.js
@@ -1,1193 +1,1290 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const {
-  _
-} = Cypress;
-const {
-  Promise
-} = Cypress;
-const RESPONSE_TIMEOUT = 22222;
-
-describe("src/cy/commands/request", () => context("#request", function() {
-  beforeEach(function() {
-    cy.stub(Cypress, "backend").callThrough();
-    return Cypress.config("responseTimeout", RESPONSE_TIMEOUT);
-  });
-
-  describe("argument signature", function() {
-    beforeEach(function() {
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({ isOkStatusCode: true, status: 200 });
-
-      return this.expectOptionsToBe = function(opts) {
-        _.defaults(opts, {
-          failOnStatusCode: true,
-          retryOnNetworkFailure: true,
-          retryOnStatusCodeFailure: false,
-          gzip: true,
-          followRedirect: true,
-          timeout: RESPONSE_TIMEOUT,
-          method: "GET"
-        });
-
-        const options = backend.firstCall.args[1];
-
-        _.each(options, (value, key) => expect(options[key]).to.deep.eq(opts[key], `failed on property: (${key})`));
-        return _.each(opts, (value, key) => expect(opts[key]).to.deep.eq(options[key], `failed on property: (${key})`));
-      };
-    });
-
-    it("accepts object with url", () => cy.request({url: "http://localhost:8000/foo"}).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8000/foo"
-      });
-    }));
-
-    it("accepts object with url, method, headers, body", () => cy.request({
-      url: "http://github.com/users",
-      method: "POST",
-      body: {name: "brian"},
-      headers: {
-        "x-token": "abc123"
-      }
-    }).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://github.com/users",
-        method: "POST",
-        json: true,
-        body: {name: "brian"},
-        headers: {
-          "x-token": "abc123"
-        }
-      });
-    }));
-
-    it("accepts object with url + timeout", () => cy.request({url: "http://localhost:8000/foo", timeout: 23456}).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8000/foo",
-        timeout: 23456
-      });
-    }));
-
-    it("accepts string url", () => cy.request("http://localhost:8080/status").then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8080/status"
-      });
-    }));
-
-    it("accepts method + url", () => cy.request("DELETE", "http://localhost:1234/users/1").then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:1234/users/1",
-        method: "DELETE"
-      });
-    }));
-
-    it("accepts method + url + body", () => cy.request("POST", "http://localhost:8080/users", {name: "brian"}).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8080/users",
-        method: "POST",
-        body: {name: "brian"},
-        json: true
-      });
-    }));
-
-    it("accepts url + body", () => cy.request("http://www.github.com/projects/foo", {commits: true}).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://www.github.com/projects/foo",
-        body: {commits: true},
-        json: true
-      });
-    }));
-
-    it("accepts url + string body", () => cy.request("http://www.github.com/projects/foo", "foo").then(function() {
-      return this.expectOptionsToBe({
-        url: "http://www.github.com/projects/foo",
-        body: "foo"
-      });
-    }));
-
-    context("method normalization", () => it("uppercases method", () => cy.request("post", "https://www.foo.com").then(function() {
-      return this.expectOptionsToBe({
-        url: "https://www.foo.com/",
-        method: "POST"
-      });
-    })));
-
-    context("url normalization", function() {
-      it("uses absolute urls and adds trailing slash", function() {
-        Cypress.config("baseUrl", "http://localhost:8080/app");
-
-        return cy.request("https://www.foo.com").then(function() {
-          return this.expectOptionsToBe({
-            url: "https://www.foo.com/"
-          });
-        });
-      });
-
-      it("uses localhost urls", () => cy.request("localhost:1234").then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/"
-        });
-      }));
-
-      it("uses www urls", () => cy.request("www.foo.com").then(function() {
-        return this.expectOptionsToBe({
-          url: "http://www.foo.com/"
-        });
-      }));
-
-      it("prefixes with baseUrl when origin is empty", function() {
-        cy.stub(cy, "getRemoteLocation").withArgs("origin").returns("");
-        Cypress.config("baseUrl", "http://localhost:8080/app");
-
-        return cy.request("/foo/bar?cat=1").then(function() {
-          return this.expectOptionsToBe({
-            url: "http://localhost:8080/app/foo/bar?cat=1"
-          });
-        });
-      });
-
-      it("prefixes with baseUrl over current origin", function() {
-        Cypress.config("baseUrl", "http://localhost:8080/app");
-        cy.stub(cy, "getRemoteLocation").withArgs("origin").returns("http://localhost:1234");
-
-        return cy.request("foobar?cat=1").then(function() {
-          return this.expectOptionsToBe({
-            url: "http://localhost:8080/app/foobar?cat=1"
-          });
-        });
-      });
-
-      //# https://github.com/cypress-io/cypress/issues/5274
-      it("encode url with ’ character in pathname", () => cy.request({ url: 'http://localhost:1234/’' }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/%E2%80%99"
-        });
-      }));
-
-      it("dont re-encode url with ’ escaped in pathname", () => cy.request({ url: encodeURI('http://localhost:1234/’') }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/%E2%80%99"
-        });
-      }));
-
-      it("encode url with % character in pathname", () => cy.request({ url: 'http://localhost:1234/%' }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/%"
-        });
-      }));
-
-      it("dont re-encode url with % escaped in pathname", () => cy.request({ url: encodeURI('http://localhost:1234/%') }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/%25"
-        });
-      }));
-
-      it("encode url with Astral Plane Unicode in pathname", () => cy.request({ url: 'http://localhost:1234/😀' }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/%F0%9F%98%80"
-        });
-      }));
-
-      it("dont re-encode url with Astral Plane Unicode escaped character in pathname", () => cy.request({ url: encodeURI('http://localhost:1234/😀') }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:1234/%F0%9F%98%80"
-        });
-      }));
-
-      it("should percent escape Unicode in pathname and convert Unicode in domain name properly", () => cy.request({ url: 'http://localhost😀:1234/😀' }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://xn--localhost-ob26h:1234/%F0%9F%98%80"
-        });
-      }));
-
-      return it("should percent escape Unicode in pathname and convert Unicode in domain name with URI encoded URL", () => cy.request({ url: encodeURI('http://localhost😀:1234/😀') }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://xn--localhost-ob26h:1234/%F0%9F%98%80"
-        });
-      }));
-    });
-
-    context("gzip", () => it("can turn off gzipping", () => cy.request({
-      url: "http://localhost:8080",
-      gzip: false
-    }).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8080/",
-        gzip: false
-      });
-    })));
-
-    context("auth", () => it("sends auth when it is an object", () => cy.request({
-      url: "http://localhost:8888",
-      auth: {
-        user: "brian",
-        pass: "password"
-      }
-    }).then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8888/",
-        auth: {
-          user: "brian",
-          pass: "password"
+const { stripIndent } = require('common-tags')
+const { _, Promise } = Cypress
+
+const RESPONSE_TIMEOUT = 22222
+
+describe('src/cy/commands/request', () => {
+  context('#request', () => {
+    beforeEach(() => {
+      cy.stub(Cypress, 'backend').callThrough()
+
+      Cypress.config('responseTimeout', RESPONSE_TIMEOUT)
+    })
+
+    describe('argument signature', () => {
+      beforeEach(function () {
+        const backend = Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: true, status: 200 })
+
+        this.expectOptionsToBe = function (opts) {
+          _.defaults(opts, {
+            failOnStatusCode: true,
+            retryOnNetworkFailure: true,
+            retryOnStatusCodeFailure: false,
+            gzip: true,
+            followRedirect: true,
+            timeout: RESPONSE_TIMEOUT,
+            method: 'GET',
+          })
+
+          const options = backend.firstCall.args[1]
+
+          _.each(options, (value, key) => {
+            expect(options[key]).to.deep.eq(opts[key], `failed on property: (${key})`)
+          })
+
+          _.each(opts, (value, key) => {
+            expect(opts[key]).to.deep.eq(options[key], `failed on property: (${key})`)
+          })
         }
-      });
-    })));
-
-    context("followRedirect", function() {
-      it("is true by default", () => cy.request("http://localhost:8888")
-      .then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:8888/"
-        });
-      }));
-
-      it("can be set to false", () => cy.request({
-        url: "http://localhost:8888",
-        followRedirect: false
       })
-      .then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:8888/",
-          followRedirect: false
-        });
-      }));
-
-      return it("normalizes followRedirects -> followRedirect", () => cy.request({
-        url: "http://localhost:8888",
-        followRedirects: false
+
+      it('accepts object with url', () => {
+        cy.request({ url: 'http://localhost:8000/foo' }).then(function () {
+          this.expectOptionsToBe({
+            url: 'http://localhost:8000/foo',
+          })
+        })
+      })
+
+      it('accepts object with url, method, headers, body', () => {
+        cy.request({
+          url: 'http://github.com/users',
+          method: 'POST',
+          body: { name: 'brian' },
+          headers: {
+            'x-token': 'abc123',
+          },
+        })
+        .then(function () {
+          this.expectOptionsToBe({
+            url: 'http://github.com/users',
+            method: 'POST',
+            json: true,
+            body: { name: 'brian' },
+            headers: {
+              'x-token': 'abc123',
+            },
+          })
+        })
+      })
+
+      it('accepts object with url + timeout', () => {
+        cy.request({ url: 'http://localhost:8000/foo', timeout: 23456 }).then(function () {
+          this.expectOptionsToBe({
+            url: 'http://localhost:8000/foo',
+            timeout: 23456,
+          })
+        })
+      })
+
+      it('accepts string url', () => {
+        cy.request('http://localhost:8080/status').then(function () {
+          this.expectOptionsToBe({
+            url: 'http://localhost:8080/status',
+          })
+        })
+      })
+
+      it('accepts method + url', () => {
+        cy.request('DELETE', 'http://localhost:1234/users/1').then(function () {
+          this.expectOptionsToBe({
+            url: 'http://localhost:1234/users/1',
+            method: 'DELETE',
+          })
+        })
+      })
+
+      it('accepts method + url + body', () => {
+        cy.request('POST', 'http://localhost:8080/users', { name: 'brian' }).then(function () {
+          this.expectOptionsToBe({
+            url: 'http://localhost:8080/users',
+            method: 'POST',
+            body: { name: 'brian' },
+            json: true,
+          })
+        })
+      })
+
+      it('accepts url + body', () => {
+        cy.request('http://www.github.com/projects/foo', { commits: true }).then(function () {
+          this.expectOptionsToBe({
+            url: 'http://www.github.com/projects/foo',
+            body: { commits: true },
+            json: true,
+          })
+        })
+      })
+
+      it('accepts url + string body', () => {
+        cy.request('http://www.github.com/projects/foo', 'foo').then(function () {
+          this.expectOptionsToBe({
+            url: 'http://www.github.com/projects/foo',
+            body: 'foo',
+          })
+        })
+      })
+
+      context('method normalization', () => {
+        it('uppercases method', () => {
+          cy.request('post', 'https://www.foo.com').then(function () {
+            this.expectOptionsToBe({
+              url: 'https://www.foo.com/',
+              method: 'POST',
+            })
+          })
+        })
+      })
+
+      context('url normalization', () => {
+        it('uses absolute urls and adds trailing slash', () => {
+          Cypress.config('baseUrl', 'http://localhost:8080/app')
+
+          cy.request('https://www.foo.com').then(function () {
+            this.expectOptionsToBe({
+              url: 'https://www.foo.com/',
+            })
+          })
+        })
+
+        it('uses localhost urls', () => {
+          cy.request('localhost:1234').then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/',
+            })
+          })
+        })
+
+        it('uses www urls', () => {
+          cy.request('www.foo.com').then(function () {
+            this.expectOptionsToBe({
+              url: 'http://www.foo.com/',
+            })
+          })
+        })
+
+        it('prefixes with baseUrl when origin is empty', () => {
+          cy.stub(cy, 'getRemoteLocation').withArgs('origin').returns('')
+          Cypress.config('baseUrl', 'http://localhost:8080/app')
+
+          cy.request('/foo/bar?cat=1').then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8080/app/foo/bar?cat=1',
+            })
+          })
+        })
+
+        it('prefixes with baseUrl over current origin', () => {
+          Cypress.config('baseUrl', 'http://localhost:8080/app')
+          cy.stub(cy, 'getRemoteLocation').withArgs('origin').returns('http://localhost:1234')
+
+          cy.request('foobar?cat=1').then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8080/app/foobar?cat=1',
+            })
+          })
+        })
+
+        // https://github.com/cypress-io/cypress/issues/5274
+        it('encode url with ’ character in pathname', () => {
+          cy.request({ url: 'http://localhost:1234/’' }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/%E2%80%99',
+            })
+          })
+        })
+
+        it('dont re-encode url with ’ escaped in pathname', () => {
+          cy.request({ url: encodeURI('http://localhost:1234/’') }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/%E2%80%99',
+            })
+          })
+        })
+
+        it('encode url with % character in pathname', () => {
+          cy.request({ url: 'http://localhost:1234/%' }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/%',
+            })
+          })
+        })
+
+        it('dont re-encode url with % escaped in pathname', () => {
+          cy.request({ url: encodeURI('http://localhost:1234/%') }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/%25',
+            })
+          })
+        })
+
+        it('encode url with Astral Plane Unicode in pathname', () => {
+          cy.request({ url: 'http://localhost:1234/😀' }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/%F0%9F%98%80',
+            })
+          })
+        })
+
+        it('dont re-encode url with Astral Plane Unicode escaped character in pathname', () => {
+          cy.request({ url: encodeURI('http://localhost:1234/😀') }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:1234/%F0%9F%98%80',
+            })
+          })
+        })
+
+        it('should percent escape Unicode in pathname and convert Unicode in domain name properly', () => {
+          cy.request({ url: 'http://localhost😀:1234/😀' }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://xn--localhost-ob26h:1234/%F0%9F%98%80',
+            })
+          })
+        })
+
+        it('should percent escape Unicode in pathname and convert Unicode in domain name with URI encoded URL', () => {
+          cy.request({ url: encodeURI('http://localhost😀:1234/😀') }).then(function () {
+            this.expectOptionsToBe({
+              url: 'http://xn--localhost-ob26h:1234/%F0%9F%98%80',
+            })
+          })
+        })
+      })
+
+      context('gzip', () => {
+        it('can turn off gzipping', () => {
+          cy.request({
+            url: 'http://localhost:8080',
+            gzip: false,
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8080/',
+              gzip: false,
+            })
+          })
+        })
+      })
+
+      context('auth', () => {
+        it('sends auth when it is an object', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            auth: {
+              user: 'brian',
+              pass: 'password',
+            },
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              auth: {
+                user: 'brian',
+                pass: 'password',
+              },
+            })
+          })
+        })
+      })
+
+      context('followRedirect', () => {
+        it('is true by default', () => {
+          cy.request('http://localhost:8888')
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+            })
+          })
+        })
+
+        it('can be set to false', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            followRedirect: false,
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              followRedirect: false,
+            })
+          })
+        })
+
+        it('normalizes followRedirects -> followRedirect', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            followRedirects: false,
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              followRedirect: false,
+            })
+          })
+        })
+      })
+
+      context('qs', () => {
+        it('accepts an object literal', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            qs: {
+              foo: 'bar',
+            },
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              qs: { foo: 'bar' },
+            })
+          })
+        })
+      })
+
+      context('form', () => {
+        it('accepts an object literal for body', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            form: true,
+            body: {
+              foo: 'bar',
+            },
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              form: true,
+              body: { foo: 'bar' },
+            })
+          })
+        })
+
+        it('accepts a string for body', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            form: true,
+            body: 'foo=bar&baz=quux',
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              form: true,
+              body: 'foo=bar&baz=quux',
+            })
+          })
+        })
+
+        // https://github.com/cypress-io/cypress/issues/2923
+        it('application/x-www-form-urlencoded w/ an object body uses form: true', () => {
+          cy.request({
+            url: 'http://localhost:8888',
+            headers: {
+              'a': 'b',
+              'Content-type': 'application/x-www-form-urlencoded',
+            },
+            body: { foo: 'bar' },
+          })
+          .then(function () {
+            this.expectOptionsToBe({
+              url: 'http://localhost:8888/',
+              form: true,
+              headers: {
+                'a': 'b',
+                'Content-type': 'application/x-www-form-urlencoded',
+              },
+              body: { foo: 'bar' },
+            })
+          })
+        })
       })
-      .then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:8888/",
-          followRedirect: false
-        });
-      }));
-    });
-
-    context("qs", () => it("accepts an object literal", () => cy.request({
-      url: "http://localhost:8888",
-      qs: {
-        foo: "bar"
-      }
     })
-    .then(function() {
-      return this.expectOptionsToBe({
-        url: "http://localhost:8888/",
-        qs: {foo: "bar"}
-      });
-    })));
-
-    return context("form", function() {
-      it("accepts an object literal for body", () => cy.request({
-        url: "http://localhost:8888",
-        form: true,
-        body: {
-          foo: "bar"
-        }
+
+    describe('failOnStatus', () => {
+      it('is deprecated but does not fail even on 500 when failOnStatus=false', () => {
+        const warning = cy.spy(Cypress.utils, 'warning')
+
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: false, status: 500 })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          failOnStatus: false,
+        })
+        .then((resp) => {
+          // make sure it really was 500!
+          expect(resp.status).to.eq(500)
+          expect(warning.lastCall.args[0]).to.include('The `cy.request()` `failOnStatus` option has been renamed to `failOnStatusCode`. Please update your code. This option will be removed at a later time.')
+        })
       })
-      .then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:8888/",
-          form: true,
-          body: {foo: "bar"}
-        });
-      }));
-
-      it("accepts a string for body", () => cy.request({
-        url: "http://localhost:8888",
-        form: true,
-        body: "foo=bar&baz=quux"
+    })
+
+    describe('failOnStatusCode', () => {
+      it('does not fail on status 401', () => {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: false, status: 401 })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          failOnStatusCode: false,
+        })
+        .then((resp) => {
+          // make sure it really was 500!
+          expect(resp.status).to.eq(401)
+        })
+      })
+    })
+
+    describe('method', () => {
+      it('can use M-SEARCH method', () => {
+        cy.request({
+          url: 'http://localhost:3500/dump-method',
+          method: 'm-Search',
+        })
+        .then((res) => {
+          expect(res.body).to.contain('M-SEARCH')
+        })
       })
-      .then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:8888/",
-          form: true,
-          body: "foo=bar&baz=quux"
-        });
-      }));
-
-      //# https://github.com/cypress-io/cypress/issues/2923
-      return it("application/x-www-form-urlencoded w/ an object body uses form: true", () => cy.request({
-        url: "http://localhost:8888",
-        headers: {
-          "a": "b",
-          "Content-type": "application/x-www-form-urlencoded"
-        },
-        body: { foo: "bar" }
-      }).then(function() {
-        return this.expectOptionsToBe({
-          url: "http://localhost:8888/",
-          form: true,
+    })
+
+    describe('headers', () => {
+      it('can send user-agent header', () => {
+        cy.request({
+          url: 'http://localhost:3500/dump-headers',
           headers: {
-            "a": "b",
-            "Content-type": "application/x-www-form-urlencoded"
+            'user-agent': 'something special',
           },
-          body: { foo: "bar" }
-        });
-      }));
-    });
-  });
-
-  describe("failOnStatus", () => it("is deprecated but does not fail even on 500 when failOnStatus=false", function() {
-    const warning = cy.spy(Cypress.utils, "warning");
-
-    const backend = Cypress.backend
-    .withArgs("http:request")
-    .resolves({ isOkStatusCode: false, status: 500 });
-
-    return cy.request({
-      url: "http://localhost:1234/foo",
-      failOnStatus: false
+        })
+        .then((res) => {
+          expect(res.body).to.contain('"user-agent":"something special"')
+        })
+      })
     })
-    .then(function(resp) {
-      //# make sure it really was 500!
-      expect(resp.status).to.eq(500);
-      return expect(warning.lastCall.args[0]).to.include("The `cy.request()` `failOnStatus` option has been renamed to `failOnStatusCode`. Please update your code. This option will be removed at a later time.");
-    });
-  }));
-
-  describe("failOnStatusCode", () => it("does not fail on status 401", function() {
-    const backend = Cypress.backend
-    .withArgs("http:request")
-    .resolves({ isOkStatusCode: false, status: 401 });
-
-    return cy.request({
-      url: "http://localhost:1234/foo",
-      failOnStatusCode: false
+
+    describe('subjects', () => {
+      it('resolves with response obj', () => {
+        const resp = {
+          status: 200,
+          isOkStatusCode: true,
+          body: '<html>foo</html>',
+          headers: { foo: 'bar' },
+        }
+
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves(resp)
+
+        cy.request('http://www.foo.com').then((subject) => {
+          expect(subject).to.deep.eq(resp)
+        })
+      })
     })
-    .then(resp => //# make sure it really was 500!
-    expect(resp.status).to.eq(401));
-  }));
-
-  describe("method", () => it("can use M-SEARCH method", () => cy.request({
-    url: 'http://localhost:3500/dump-method',
-    method: 'm-Search'
-  }).then(res => {
-    return expect(res.body).to.contain('M-SEARCH');
-  })));
-
-  describe("headers", () => it("can send user-agent header", () => cy.request({
-    url: "http://localhost:3500/dump-headers",
-    headers: {
-      "user-agent": "something special"
-    }
-  }).then(res => expect(res.body).to.contain('"user-agent":"something special"'))));
-
-  describe("subjects", () => it("resolves with response obj", function() {
-    const resp = {
-      status: 200,
-      isOkStatusCode: true,
-      body: "<html>foo</html>",
-      headers: {foo: "bar"}
-    };
-
-    const backend = Cypress.backend
-    .withArgs("http:request")
-    .resolves(resp);
-
-    return cy.request("http://www.foo.com").then(subject => expect(subject).to.deep.eq(resp));
-  }));
-
-  describe("timeout", function() {
-    beforeEach(function() {
-      let backend;
-      return backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({isOkStatusCode: true, status: 200});
-    });
-
-    it("sets timeout to Cypress.config(responseTimeout)", function() {
-      Cypress.config("responseTimeout", 2500);
-
-      const timeout = cy.spy(Promise.prototype, "timeout");
-
-      return cy.request("http://www.foo.com").then(() => expect(timeout).to.be.calledWith(2500));
-    });
-
-    it("can override timeout", function() {
-      const timeout = cy.spy(Promise.prototype, "timeout");
-
-      return cy.request({url: "http://www.foo.com", timeout: 1000}).then(() => expect(timeout).to.be.calledWith(1000));
-    });
-
-    return it("clears the current timeout and restores after success", function() {
-      cy.timeout(100);
-
-      cy.spy(cy, "clearTimeout");
-
-      return cy.request("http://www.foo.com").then(function() {
-        expect(cy.clearTimeout).to.be.calledWith("http:request");
-
-        //# restores the timeout afterwards
-        return expect(cy.timeout()).to.eq(100);
-      });
-    });
-  });
-
-  describe(".log", function() {
-    beforeEach(function() {
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "request") {
-          return this.lastLog = log;
+
+    describe('timeout', () => {
+      beforeEach(() => {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: true, status: 200 })
+      })
+
+      it('sets timeout to Cypress.config(responseTimeout)', () => {
+        Cypress.config('responseTimeout', 2500)
+
+        const timeout = cy.spy(Promise.prototype, 'timeout')
+
+        cy.request('http://www.foo.com').then(() => {
+          expect(timeout).to.be.calledWith(2500)
+        })
+      })
+
+      it('can override timeout', () => {
+        const timeout = cy.spy(Promise.prototype, 'timeout')
+
+        cy.request({ url: 'http://www.foo.com', timeout: 1000 }).then(() => {
+          expect(timeout).to.be.calledWith(1000)
+        })
+      })
+
+      it('clears the current timeout and restores after success', () => {
+        cy.timeout(100)
+
+        cy.spy(cy, 'clearTimeout')
+
+        cy.request('http://www.foo.com').then(() => {
+          expect(cy.clearTimeout).to.be.calledWith('http:request')
+
+          // restores the timeout afterwards
+          expect(cy.timeout()).to.eq(100)
+        })
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'request') {
+            this.lastLog = log
+          }
+        })
+
+        return null
+      })
+
+      it('can turn off logging', () => {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: true, status: 200 })
+
+        cy.request({
+          url: 'http://localhost:8080',
+          log: false,
+        })
+        .then(function () {
+          expect(this.lastLog).to.be.undefined
+        })
+      })
+
+      it('logs immediately before resolving', (done) => {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: true, status: 200 })
+
+        cy.on('log:added', (attrs, log) => {
+          if (log.get('name') === 'request') {
+            expect(log.get('state')).to.eq('pending')
+            expect(log.get('message')).to.eq('')
+
+            done()
+          }
+        })
+
+        cy.request('http://localhost:8080')
+      })
+
+      it('snapshots after clicking', () => {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({ isOkStatusCode: true, status: 200 })
+
+        cy.request('http://localhost:8080').then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
+
+      it('.consoleProps', () => {
+        const allRequestResponse = {
+          'Request URL': 'http://localhost:8080/foo',
+          'Request Headers': { 'x-token': 'ab123' },
+          'Request Body': { first: 'brian' },
+          'Response Headers': {
+            'Content-Type': 'application/json',
+          },
+          'Response Body': { id: 123 },
         }
-      });
-
-      return null;
-    });
-
-    it("can turn off logging", function() {
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({isOkStatusCode: true, status: 200});
-
-      return cy.request({
-        url: "http://localhost:8080",
-        log: false
-      }).then(function() {
-        return expect(this.lastLog).to.be.undefined;
-      });
-    });
-
-    it("logs immediately before resolving", function(done) {
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({isOkStatusCode: true, status: 200});
-
-      cy.on("log:added", function(attrs, log) {
-        if (log.get("name") === "request") {
-          expect(log.get("state")).to.eq("pending");
-          expect(log.get("message")).to.eq("");
-          return done();
+
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({
+          duration: 10,
+          status: 201,
+          isOkStatusCode: true,
+          body: { id: 123 },
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          requestHeaders: { 'x-token': 'ab123' },
+          requestBody: { first: 'brian' },
+          allRequestResponses: [allRequestResponse],
+        })
+
+        cy.request({
+          url: 'http://localhost:8080/foo',
+          headers: { 'x-token': 'abc123' },
+          method: 'POST',
+          body: { first: 'brian' },
+        })
+        .then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'request',
+            Request: allRequestResponse,
+            Yielded: {
+              duration: 10,
+              status: 201,
+              body: { id: 123 },
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            },
+          })
+        })
+      })
+
+      it('.consoleProps with array of allRequestResponses', () => {
+        const allRequestResponses = [{
+          'Request URL': 'http://localhost:8080/foo',
+          'Request Headers': { 'x-token': 'ab123' },
+          'Request Body': { first: 'brian' },
+          'Response Headers': {
+            'Content-Type': 'application/json',
+          },
+          'Response Body': { id: 123 },
+        }, {
+          'Request URL': 'http://localhost:8080/foo',
+          'Request Headers': { 'x-token': 'ab123' },
+          'Request Body': { first: 'brian' },
+          'Response Headers': {
+            'Content-Type': 'application/json',
+          },
+          'Response Body': { id: 123 },
+        }]
+
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({
+          duration: 10,
+          status: 201,
+          isOkStatusCode: true,
+          body: { id: 123 },
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          requestHeaders: { 'x-token': 'ab123' },
+          requestBody: { first: 'brian' },
+          allRequestResponses,
+        })
+
+        cy.request({
+          url: 'http://localhost:8080/foo',
+          headers: { 'x-token': 'abc123' },
+          method: 'POST',
+          body: { first: 'brian' },
+        })
+        .then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'request',
+            Requests: allRequestResponses,
+            Yielded: {
+              duration: 10,
+              status: 201,
+              body: { id: 123 },
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            },
+          })
+        })
+      })
+
+      describe('.renderProps', () => {
+        describe('in any case', () => {
+          it('sends correct message', () => {
+            Cypress.backend
+            .withArgs('http:request')
+            .resolves({ isOkStatusCode: true, status: 201 })
+
+            cy.request('http://localhost:8080/foo').then(function () {
+              expect(this.lastLog.invoke('renderProps').message).to.equal('GET 201 http://localhost:8080/foo')
+            })
+          })
+        })
+
+        describe('when response is successful', () => {
+          it('sends correct indicator', () => {
+            Cypress.backend
+            .withArgs('http:request')
+            .resolves({ isOkStatusCode: true, status: 201 })
+
+            cy.request('http://localhost:8080/foo').then(function () {
+              expect(this.lastLog.invoke('renderProps').indicator).to.equal('successful')
+            })
+          })
+        })
+
+        describe('when response is outside 200 range', () => {
+          it('sends correct indicator', function (done) {
+            cy.on('fail', (err) => {
+              expect(this.lastLog.invoke('renderProps').indicator).to.equal('bad')
+
+              done()
+            })
+
+            Cypress.backend
+            .withArgs('http:request')
+            .resolves({ status: 500 })
+
+            cy.request('http://localhost:8080/foo')
+          })
+        })
+      })
+    })
+
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'request') {
+            this.lastLog = log
+            this.logs.push(log)
+          }
+        })
+
+        return null
+      })
+
+      it('throws when no url is passed', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` requires a `url`. You did not provide a `url`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request()
+      })
+
+      it('throws when url is not FQDN', function (done) {
+        Cypress.config('baseUrl', '')
+        cy.stub(cy, 'getRemoteLocation').withArgs('origin').returns('')
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` must be provided a fully qualified `url` - one that begins with `http`. By default `cy.request()` will use either the current window\'s origin or the `baseUrl` in `cypress.json`. Neither of those values were present.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request('/foo/bar')
+      })
+
+      it('throws when url is not FQDN, notes that configFile is disabled', function (done) {
+        Cypress.config('baseUrl', '')
+        Cypress.config('configFile', false)
+        cy.stub(cy, 'getRemoteLocation').withArgs('origin').returns('')
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` must be provided a fully qualified `url` - one that begins with `http`. By default `cy.request()` will use either the current window\'s origin or the `baseUrl` in `cypress.json` (currently disabled by --config-file=false). Neither of those values were present.')
+
+          done()
+        })
+
+        cy.request('/foo/bar')
+      })
+
+      it('throws when url is not FQDN, notes that configFile is non-default', function (done) {
+        Cypress.config('baseUrl', '')
+        Cypress.config('configFile', 'foo.json')
+        cy.stub(cy, 'getRemoteLocation').withArgs('origin').returns('')
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` must be provided a fully qualified `url` - one that begins with `http`. By default `cy.request()` will use either the current window\'s origin or the `baseUrl` in `foo.json`. Neither of those values were present.')
+
+          done()
+        })
+
+        cy.request('/foo/bar')
+      })
+
+      it('throws when url isnt a string', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` requires the `url` to be a string.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: [],
+        })
+      })
+
+      it('throws when auth is truthy but not an object', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` must be passed an object literal for the `auth` option.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          auth: 'foobar',
+        })
+      })
+
+      it('throws when headers is truthy but not an object', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` requires the `headers` option to be an object literal.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          headers: 'foo=bar',
+        })
+      })
+
+      it('throws on invalid method', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` was called with an invalid method: `FOO`. Method can be: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`, or any other method supported by Node\'s HTTP parser.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          method: 'FOO',
+        })
+      })
+
+      it('throws when gzip is not boolean', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` requires the `gzip` option to be a boolean.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          gzip: {},
+        })
+      })
+
+      it('throws when form isnt a boolean', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.request()` requires the `form` option to be a boolean.\n\nIf you\'re trying to send a `x-www-form-urlencoded` request then pass either a string or object literal to the `body` property.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: 'http://localhost:1234/foo',
+          form: { foo: 'bar' },
+        })
+      })
+
+      it('throws when failOnStatusCode is false and retryOnStatusCodeFailure is true', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.request()` was invoked with `{ failOnStatusCode: false, retryOnStatusCodeFailure: true }`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+
+        cy.request({
+          url: 'http://foobarbaz',
+          failOnStatusCode: false,
+          retryOnStatusCodeFailure: true,
+        })
+      })
+
+      it('throws when status code doesnt start with 2 and failOnStatusCode is true', function (done) {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({
+          isOkStatusCode: false,
+          status: 500,
+          statusText: 'Server Error',
+          headers: {
+            baz: 'quux',
+          },
+          body: 'response body',
+          requestHeaders: {
+            foo: 'bar',
+          },
+          requestBody: 'request body',
+          redirects: [
+            '301: http://www.google.com',
+          ],
+        })
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+          expect(err.message).to.include(stripIndent`\
+            \`cy.request()\` failed on:
+
+            http://localhost:1234/foo
+
+            The response we received from your web server was:
+
+              > 500: Server Error
+
+            This was considered a failure because the status code was not \`2xx\` or \`3xx\`.
+
+            If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`
+
+            -----------------------------------------------------------
+
+            The request we sent was:
+
+            Method: POST
+            URL: http://localhost:1234/foo
+            Headers: {
+              \"foo\": \"bar\"
+            }
+            Body: request body
+            Redirects: [
+              \"301: http://www.google.com\"
+            ]
+
+            -----------------------------------------------------------
+
+            The response we got was:
+
+            Status: 500 - Server Error
+            Headers: {
+              \"baz\": \"quux\"
+            }
+            Body: response body`)
+
+          done()
+        })
+
+        cy.request({
+          method: 'POST',
+          url: 'http://localhost:1234/foo',
+          body: {
+            username: 'cypress',
+          },
+        })
+      })
+
+      // https://github.com/cypress-io/cypress/issues/4346
+      it('throws on network failure when nested', (done) => {
+        cy.request('http://localhost:3500/dump-method')
+        .then(() => {
+          cy.request('http://0.0.0.0:12345')
+        })
+
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.request()` failed trying to load:')
+
+          done()
+        })
+      })
+
+      it('displays body_circular when body is circular', function (done) {
+        const foo = {
+          bar: {
+            baz: {},
+          },
         }
-      });
-
-      return cy.request("http://localhost:8080");
-    });
-
-    it("snapshots after clicking", function() {
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({isOkStatusCode: true, status: 200});
-
-      return cy.request("http://localhost:8080").then(function() {
-        const {
-          lastLog
-        } = this;
-
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      });
-    });
-
-    it(".consoleProps", function() {
-      const allRequestResponse = {
-        "Request URL": "http://localhost:8080/foo",
-        "Request Headers": {"x-token": "ab123"},
-        "Request Body": {first: "brian"},
-        "Response Headers": {
-          "Content-Type": "application/json"
-        },
-        "Response Body": {id: 123}
-      };
-
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({
-        duration: 10,
-        status: 201,
-        isOkStatusCode: true,
-        body: {id: 123},
-        headers: {
-          "Content-Type": "application/json"
-        },
-        requestHeaders: {"x-token": "ab123"},
-        requestBody: {first: "brian"},
-        allRequestResponses: [allRequestResponse]
-      });
-
-      return cy.request({
-        url: "http://localhost:8080/foo",
-        headers: {"x-token": "abc123"},
-        method: "POST",
-        body: {first: "brian"}
-      }).then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "request",
-          Request: allRequestResponse,
-          Yielded: {
-            duration: 10,
-            status: 201,
-            body: {id: 123},
-            headers: {
-              "Content-Type": "application/json"
+
+        foo.bar.baz.quux = foo
+
+        cy.request({
+          method: 'POST',
+          url: 'http://foo.invalid/',
+          body: foo,
+        })
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq(stripIndent`\
+            The \`body\` parameter supplied to \`cy.request()\` contained a circular reference at the path "bar.baz.quux".
+
+            \`body\` can only be a string or an object with no circular references.`)
+
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+          done()
+        })
+      })
+
+      it('does not include redirects when there were no redirects', function (done) {
+        Cypress.backend
+        .withArgs('http:request')
+        .resolves({
+          isOkStatusCode: false,
+          status: 500,
+          statusText: 'Server Error',
+          headers: {
+            baz: 'quux',
+          },
+          body: 'response body',
+          requestHeaders: {
+            foo: 'bar',
+          },
+          requestBody: 'request body',
+        })
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+          expect(err.message).to.include(stripIndent`\
+            \`cy.request()\` failed on:
+
+            http://localhost:1234/foo
+
+            The response we received from your web server was:
+
+              > 500: Server Error
+
+            This was considered a failure because the status code was not \`2xx\` or \`3xx\`.
+
+            If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`
+
+            -----------------------------------------------------------
+
+            The request we sent was:
+
+            Method: POST
+            URL: http://localhost:1234/foo
+            Headers: {
+              \"foo\": \"bar\"
             }
-          }
-        });
-      });
-    });
-
-    it(".consoleProps with array of allRequestResponses", function() {
-      const allRequestResponses = [{
-        "Request URL": "http://localhost:8080/foo",
-        "Request Headers": {"x-token": "ab123"},
-        "Request Body": {first: "brian"},
-        "Response Headers": {
-          "Content-Type": "application/json"
-        },
-        "Response Body": {id: 123}
-      }, {
-        "Request URL": "http://localhost:8080/foo",
-        "Request Headers": {"x-token": "ab123"},
-        "Request Body": {first: "brian"},
-        "Response Headers": {
-          "Content-Type": "application/json"
-        },
-        "Response Body": {id: 123}
-      }];
-
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({
-        duration: 10,
-        status: 201,
-        isOkStatusCode: true,
-        body: {id: 123},
-        headers: {
-          "Content-Type": "application/json"
-        },
-        requestHeaders: {"x-token": "ab123"},
-        requestBody: {first: "brian"},
-        allRequestResponses
-      });
-
-      return cy.request({
-        url: "http://localhost:8080/foo",
-        headers: {"x-token": "abc123"},
-        method: "POST",
-        body: {first: "brian"}
-      }).then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "request",
-          Requests: allRequestResponses,
-          Yielded: {
-            duration: 10,
-            status: 201,
-            body: {id: 123},
-            headers: {
-              "Content-Type": "application/json"
+            Body: request body
+
+            -----------------------------------------------------------
+
+            The response we got was:
+
+            Status: 500 - Server Error
+            Headers: {
+              \"baz\": \"quux\"
             }
-          }
-        });
-      });
-    });
+            Body: response body`)
 
-    return describe(".renderProps", function() {
-      describe("in any case", () => it("sends correct message", function() {
-        const backend = Cypress.backend
-        .withArgs("http:request")
-        .resolves({ isOkStatusCode: true, status: 201 });
+          done()
+        })
 
-        return cy.request("http://localhost:8080/foo").then(function() {
-          return expect(this.lastLog.invoke("renderProps").message).to.equal("GET 201 http://localhost:8080/foo");
-        });
-      }));
+        cy.request({
+          method: 'POST',
+          url: 'http://localhost:1234/foo',
+          body: {
+            username: 'cypress',
+          },
+        })
+      })
 
-      describe("when response is successful", () => it("sends correct indicator", function() {
-        const backend = Cypress.backend
-        .withArgs("http:request")
-        .resolves({ isOkStatusCode: true, status: 201 });
+      it('logs once on error', function (done) {
+        const error = new Error('request failed')
 
-        return cy.request("http://localhost:8080/foo").then(function() {
-          return expect(this.lastLog.invoke("renderProps").indicator).to.equal("successful");
-        });
-      }));
+        error.backend = true
 
-      return describe("when response is outside 200 range", () => it("sends correct indicator", function(done) {
-        cy.on("fail", err => {
-          expect(this.lastLog.invoke("renderProps").indicator).to.equal("bad");
-          return done();
-        });
+        Cypress.backend
+        .withArgs('http:request')
+        .rejects(error)
 
-        const backend = Cypress.backend
-        .withArgs("http:request")
-        .resolves({ status: 500 });
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-        return cy.request("http://localhost:8080/foo");
-      }));
-    });
-  });
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
 
-  return describe("errors", function() {
-    beforeEach(function() {
-      Cypress.config("defaultCommandTimeout", 50);
+          done()
+        })
 
-      this.logs = [];
+        cy.request('http://localhost:1234/foo')
+      })
 
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "request") {
-          this.lastLog = log;
-          return this.logs.push(log);
-        }
-      });
-
-      return null;
-    });
-
-    it("throws when no url is passed", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` requires a `url`. You did not provide a `url`.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request();
-    });
-
-    it("throws when url is not FQDN", function(done) {
-      Cypress.config("baseUrl", "");
-      cy.stub(cy, "getRemoteLocation").withArgs("origin").returns("");
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` must be provided a fully qualified `url` - one that begins with `http`. By default `cy.request()` will use either the current window's origin or the `baseUrl` in `cypress.json`. Neither of those values were present.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request("/foo/bar");
-    });
-
-    it("throws when url is not FQDN, notes that configFile is disabled", function(done) {
-      Cypress.config("baseUrl", "");
-      Cypress.config("configFile", false);
-      cy.stub(cy, "getRemoteLocation").withArgs("origin").returns("");
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` must be provided a fully qualified `url` - one that begins with `http`. By default `cy.request()` will use either the current window's origin or the `baseUrl` in `cypress.json` (currently disabled by --config-file=false). Neither of those values were present.");
-        return done();
-      });
-
-      return cy.request("/foo/bar");
-    });
-
-    it("throws when url is not FQDN, notes that configFile is non-default", function(done) {
-      Cypress.config("baseUrl", "");
-      Cypress.config("configFile", "foo.json");
-      cy.stub(cy, "getRemoteLocation").withArgs("origin").returns("");
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` must be provided a fully qualified `url` - one that begins with `http`. By default `cy.request()` will use either the current window's origin or the `baseUrl` in `foo.json`. Neither of those values were present.");
-        return done();
-      });
-
-      return cy.request("/foo/bar");
-    });
-
-    it("throws when url isnt a string", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` requires the `url` to be a string.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: []
-      });
-    });
-
-    it("throws when auth is truthy but not an object", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` must be passed an object literal for the `auth` option.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: "http://localhost:1234/foo",
-        auth: "foobar"
-      });
-    });
-
-    it("throws when headers is truthy but not an object", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` requires the `headers` option to be an object literal.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: "http://localhost:1234/foo",
-        headers: "foo=bar"
-      });
-    });
-
-    it("throws on invalid method", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` was called with an invalid method: `FOO`. Method can be: `GET`, `POST`, `PUT`, `DELETE`, `PATCH`, `HEAD`, `OPTIONS`, or any other method supported by Node's HTTP parser.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: "http://localhost:1234/foo",
-        method: "FOO"
-      });
-    });
-
-    it("throws when gzip is not boolean", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` requires the `gzip` option to be a boolean.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: "http://localhost:1234/foo",
-        gzip: {}
-      });
-    });
-
-    it("throws when form isnt a boolean", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.request()` requires the `form` option to be a boolean.\n\nIf you're trying to send a `x-www-form-urlencoded` request then pass either a string or object literal to the `body` property.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: "http://localhost:1234/foo",
-        form: {foo: "bar"}
-      });
-    });
-
-    it("throws when failOnStatusCode is false and retryOnStatusCodeFailure is true", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.request()` was invoked with `{ failOnStatusCode: false, retryOnStatusCodeFailure: true }`.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        return done();
-      });
-
-      return cy.request({
-        url: "http://foobarbaz",
-        failOnStatusCode: false,
-        retryOnStatusCodeFailure: true
-      });
-    });
-
-    it("throws when status code doesnt start with 2 and failOnStatusCode is true", function(done) {
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({
-        isOkStatusCode: false,
-        status: 500,
-        statusText: "Server Error",
-        headers: {
-          baz: "quux"
-        },
-        body: "response body",
-        requestHeaders: {
-          foo: "bar"
-        },
-        requestBody: "request body",
-        redirects: [
-          "301: http://www.google.com"
-        ]
-      });
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        expect(err.message).to.include(`\
-\`cy.request()\` failed on:
-
-http://localhost:1234/foo
-
-The response we received from your web server was:
-
-> 500: Server Error
-
-This was considered a failure because the status code was not \`2xx\` or \`3xx\`.
-
-If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`
-
------------------------------------------------------------
-
-The request we sent was:
-
-Method: POST
-URL: http://localhost:1234/foo
-Headers: {
-\"foo\": \"bar\"
-}
-Body: request body
-Redirects: [
-\"301: http://www.google.com\"
-]
-
------------------------------------------------------------
-
-The response we got was:
-
-Status: 500 - Server Error
-Headers: {
-\"baz\": \"quux\"
-}
-Body: response body\
-`);
-        return done();
-      });
-
-      return cy.request({
-        method: "POST",
-        url: "http://localhost:1234/foo",
-        body: {
-          username: "cypress"
-        }
-      });
-    });
-
-    //# https://github.com/cypress-io/cypress/issues/4346
-    it("throws on network failure when nested", function(done) {
-      cy.request("http://localhost:3500/dump-method")
-      .then(() => cy.request("http://0.0.0.0:12345"));
-
-      return cy.on("fail", function(err) {
-        expect(err.message).to.include("`cy.request()` failed trying to load:");
-        return done();
-      });
-    });
-
-    it("displays body_circular when body is circular", function(done) {
-      const foo = {
-        bar: {
-          baz: {}
-        }
-      };
-
-      foo.bar.baz.quux = foo;
-
-      cy.request({
-        method: "POST",
-        url: "http://foo.invalid/",
-        body: foo
-      });
-
-      return cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq(`\
-The \`body\` parameter supplied to \`cy.request()\` contained a circular reference at the path "bar.baz.quux".
-
-\`body\` can only be a string or an object with no circular references.\
-`
-        );
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-
-        return done();
-      });
-    });
-
-    it("does not include redirects when there were no redirects", function(done) {
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .resolves({
-        isOkStatusCode: false,
-        status: 500,
-        statusText: "Server Error",
-        headers: {
-          baz: "quux"
-        },
-        body: "response body",
-        requestHeaders: {
-          foo: "bar"
-        },
-        requestBody: "request body"
-      });
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-        expect(err.message).to.include(`\
-\`cy.request()\` failed on:
-
-http://localhost:1234/foo
-
-The response we received from your web server was:
-
-> 500: Server Error
-
-This was considered a failure because the status code was not \`2xx\` or \`3xx\`.
-
-If you do not want status codes to cause failures pass the option: \`failOnStatusCode: false\`
-
------------------------------------------------------------
-
-The request we sent was:
-
-Method: POST
-URL: http://localhost:1234/foo
-Headers: {
-\"foo\": \"bar\"
-}
-Body: request body
-
------------------------------------------------------------
-
-The response we got was:
-
-Status: 500 - Server Error
-Headers: {
-\"baz\": \"quux\"
-}
-Body: response body\
-`);
-        return done();
-      });
-
-      return cy.request({
-        method: "POST",
-        url: "http://localhost:1234/foo",
-        body: {
-          username: "cypress"
-        }
-      });
-    });
-
-    it("logs once on error", function(done) {
-      const error = new Error("request failed");
-      error.backend = true;
-
-      const backend = Cypress.backend
-      .withArgs("http:request")
-      .rejects(error);
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        return done();
-      });
-
-      return cy.request("http://localhost:1234/foo");
-    });
-
-    //# https://github.com/cypress-io/cypress/issues/5274
-    it("dont throw UNESCAPED_CHARACTERS error for url with ’ character in pathname", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.request()` failed trying to load:");
-        expect(err.message).to.not.contain("ERR_UNESCAPED_CHARACTERS");
-        return done();
-      });
-
-      return cy.request("http://localhost:1234/’");
-    });
-
-    it("dont throw UNESCAPED_CHARACTERS error for url with % character in pathname", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.request()` failed trying to load:");
-        expect(err.message).to.not.contain("ERR_UNESCAPED_CHARACTERS");
-        return done();
-      });
-
-      return cy.request("http://localhost:1234/%");
-    });
-
-    it("dont throw UNESCAPED_CHARACTERS error for url with ’ escaped in pathname", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.request()` failed trying to load:");
-        expect(err.message).to.not.contain("ERR_UNESCAPED_CHARACTERS");
-        return done();
-      });
-
-      return cy.request(encodeURI('http://localhost:1234/’'));
-    });
-
-    it("dont throw UNESCAPED_CHARACTERS error for url with Unicode in pathname from BMP to Astral Plane", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.request()` failed trying to load:");
-        expect(err.message).to.not.contain("ERR_UNESCAPED_CHARACTERS");
-        return done();
-      });
-
-      return cy.request('http://localhost:1234/😀');
-    });
-
-    it("dont throw UNESCAPED_CHARACTERS error for url with any Unicode escaped character in pathname", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.contain("`cy.request()` failed trying to load:");
-        expect(err.message).to.not.contain("ERR_UNESCAPED_CHARACTERS");
-        return done();
-      });
-
-      return cy.request(encodeURI('http://localhost:1234/😀'));
-    });
-
-    return context("displays error", function() {
-      it("displays method and url in error", function(done) {
-        const error = new Error("request failed");
-        error.backend = true;
+      // https://github.com/cypress-io/cypress/issues/5274
+      it('dont throw UNESCAPED_CHARACTERS error for url with ’ character in pathname', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.request()` failed trying to load:')
+          expect(err.message).to.not.contain('ERR_UNESCAPED_CHARACTERS')
 
-        const backend = Cypress.backend
-        .withArgs("http:request")
-        .rejects(error);
+          done()
+        })
 
-        cy.on("fail", err => {
-          expect(err.message).to.include(`\
-\`cy.request()\` failed trying to load:
+        cy.request('http://localhost:1234/’')
+      })
 
-http://localhost:1234/foo
+      it('dont throw UNESCAPED_CHARACTERS error for url with % character in pathname', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.request()` failed trying to load:')
+          expect(err.message).to.not.contain('ERR_UNESCAPED_CHARACTERS')
 
-We attempted to make an http request to this URL but the request failed without a response.
+          done()
+        })
 
-We received this error at the network level:
+        cy.request('http://localhost:1234/%')
+      })
 
-> request failed
+      it('dont throw UNESCAPED_CHARACTERS error for url with ’ escaped in pathname', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.request()` failed trying to load:')
+          expect(err.message).to.not.contain('ERR_UNESCAPED_CHARACTERS')
 
------------------------------------------------------------
+          done()
+        })
 
-The request we sent was:
+        cy.request(encodeURI('http://localhost:1234/’'))
+      })
 
-Method: GET
-URL: http://localhost:1234/foo
+      it('dont throw UNESCAPED_CHARACTERS error for url with Unicode in pathname from BMP to Astral Plane', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.request()` failed trying to load:')
+          expect(err.message).to.not.contain('ERR_UNESCAPED_CHARACTERS')
 
------------------------------------------------------------
+          done()
+        })
 
-Common situations why this would fail:
-- you don't have internet access
-- you forgot to run / boot your web server
-- your web server isn't accessible
-- you have weird network configuration settings on your computer\
-`);
-          expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-          return done();
-        });
+        cy.request('http://localhost:1234/😀')
+      })
 
-        return cy.request("http://localhost:1234/foo");
-      });
+      it('dont throw UNESCAPED_CHARACTERS error for url with any Unicode escaped character in pathname', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.contain('`cy.request()` failed trying to load:')
+          expect(err.message).to.not.contain('ERR_UNESCAPED_CHARACTERS')
 
-      return it("throws after timing out", function(done) {
-        const backend = Cypress.backend
-        .withArgs("http:request")
-        .resolves(Promise.delay(1000));
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/request");
-          expect(err.message).to.eq(`\
-\`cy.request()\` timed out waiting \`50ms\` for a response from your server.
-
-The request we sent was:
-
-Method: GET
-URL: http://localhost:1234/foo
-
-No response was received within the timeout.\
-`);
-          return done();
-        });
-
-        return cy.request({url: "http://localhost:1234/foo", timeout: 50});
-      });
-    });
-  });
-}));
+          done()
+        })
+
+        cy.request(encodeURI('http://localhost:1234/😀'))
+      })
+
+      context('displays error', () => {
+        it('displays method and url in error', (done) => {
+          const error = new Error('request failed')
+
+          error.backend = true
+
+          Cypress.backend
+          .withArgs('http:request')
+          .rejects(error)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include(stripIndent`\
+              \`cy.request()\` failed trying to load:
+
+              http://localhost:1234/foo
+
+              We attempted to make an http request to this URL but the request failed without a response.
+
+              We received this error at the network level:
+
+                > request failed
+
+              -----------------------------------------------------------
+
+              The request we sent was:
+
+              Method: GET
+              URL: http://localhost:1234/foo
+
+              -----------------------------------------------------------
+
+              Common situations why this would fail:
+                - you don't have internet access
+                - you forgot to run / boot your web server
+                - your web server isn't accessible
+                - you have weird network configuration settings on your computer`)
+
+            expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+
+            done()
+          })
+
+          cy.request('http://localhost:1234/foo')
+        })
+
+        it('throws after timing out', function (done) {
+          Cypress.backend
+          .withArgs('http:request')
+          .resolves(Promise.delay(1000))
+
+          cy.on('fail', (err) => {
+            const {
+              lastLog,
+            } = this
+
+            expect(this.logs.length).to.eq(1)
+            expect(lastLog.get('error')).to.eq(err)
+            expect(lastLog.get('state')).to.eq('failed')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/request')
+            expect(err.message).to.eq(stripIndent`\
+              \`cy.request()\` timed out waiting \`50ms\` for a response from your server.
+
+              The request we sent was:
+
+              Method: GET
+              URL: http://localhost:1234/foo
+
+              No response was received within the timeout.`)
+
+            done()
+          })
+
+          cy.request({ url: 'http://localhost:1234/foo', timeout: 50 })
+        })
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/screenshot_spec.js b/packages/driver/test/cypress/integration/commands/screenshot_spec.js
index ff2809870dbb..9b98397e40ce 100644
--- a/packages/driver/test/cypress/integration/commands/screenshot_spec.js
+++ b/packages/driver/test/cypress/integration/commands/screenshot_spec.js
@@ -1,974 +1,1092 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const $ = require("jquery");
-
-const {
-  _
-} = Cypress;
-const {
-  Promise
-} = Cypress;
-const {
-  Screenshot
-} = Cypress;
-
-const getViewportHeight = () => Math.min(cy.state("viewportHeight"), $(cy.state("window")).height());
-
-describe("src/cy/commands/screenshot", function() {
-  beforeEach(function() {
-    cy.stub(Cypress, "automation").callThrough();
+const $ = require('jquery')
+
+const { _, Promise, Screenshot } = Cypress
+
+const getViewportHeight = () => {
+  return Math.min(cy.state('viewportHeight'), $(cy.state('window')).height())
+}
+
+describe('src/cy/commands/screenshot', () => {
+  beforeEach(function () {
+    cy.stub(Cypress, 'automation').callThrough()
 
     this.serverResult = {
-      path: "/path/to/screenshot",
+      path: '/path/to/screenshot',
       size: 12,
       dimensions: { width: 20, height: 20 },
       multipart: false,
       pixelRatio: 1,
       takenAt: new Date().toISOString(),
-      name: "name",
-      blackout: [".foo"],
-      duration: 100
-    };
+      name: 'name',
+      blackout: ['.foo'],
+      duration: 100,
+    }
 
-    return this.screenshotConfig = {
-      capture: "viewport",
+    this.screenshotConfig = {
+      capture: 'viewport',
       screenshotOnRunFailure: true,
       disableTimersAndAnimations: true,
       scale: true,
-      blackout: [".foo"]
-    };});
+      blackout: ['.foo'],
+    }
+  })
 
-  context("runnable:after:run:async", function() {
-    it("is noop when not isTextTerminal", function() {
-      //# backup this property so we set it back to whatever
-      //# is correct based on what mode we're currently in
-      const isTextTerminal = Cypress.config("isTextTerminal");
+  context('runnable:after:run:async', () => {
+    it('is noop when not isTextTerminal', () => {
+      // backup this property so we set it back to whatever
+      // is correct based on what mode we're currently in
+      const isTextTerminal = Cypress.config('isTextTerminal')
 
-      Cypress.config("isTextTerminal", false);
+      Cypress.config('isTextTerminal', false)
 
-      cy.spy(Cypress, "action").log(false);
+      cy.spy(Cypress, 'action').log(false)
 
       const test = {
-        err: new Error
-      };
+        err: new Error,
+      }
 
-      const runnable = cy.state("runnable");
+      const runnable = cy.state('runnable')
 
-      return Cypress.action("runner:runnable:after:run:async", test, runnable)
-      .then(function() {
-        expect(Cypress.action).not.to.be.calledWith("cy:test:set:state");
-        return expect(Cypress.automation).not.to.be.called;}).finally(() => Cypress.config("isTextTerminal", isTextTerminal));
-    });
+      Cypress.action('runner:runnable:after:run:async', test, runnable)
+      .then(() => {
+        expect(Cypress.action).not.to.be.calledWith('cy:test:set:state')
+        expect(Cypress.automation).not.to.be.called
+      })
+      .finally(() => {
+        Cypress.config('isTextTerminal', isTextTerminal)
+      })
+    })
 
-    it("is noop when no test.err", function() {
-      Cypress.config("isInteractive", false);
+    it('is noop when no test.err', () => {
+      Cypress.config('isInteractive', false)
 
-      cy.spy(Cypress, "action").log(false);
+      cy.spy(Cypress, 'action').log(false)
 
-      const test = {};
+      const test = {}
 
-      const runnable = cy.state("runnable");
+      const runnable = cy.state('runnable')
 
-      return Cypress.action("runner:runnable:after:run:async", test, runnable)
-      .then(function() {
-        expect(Cypress.action).not.to.be.calledWith("cy:test:set:state");
-        return expect(Cypress.automation).not.to.be.called;
-      });
-    });
+      Cypress.action('runner:runnable:after:run:async', test, runnable)
+      .then(() => {
+        expect(Cypress.action).not.to.be.calledWith('cy:test:set:state')
+        expect(Cypress.automation).not.to.be.called
+      })
+    })
 
-    it("is noop when screenshotOnRunFailure is false", function() {
-      Cypress.config("isInteractive", false);
-      cy.stub(Screenshot, "getConfig").returns({
-        screenshotOnRunFailure: false
-      });
+    it('is noop when screenshotOnRunFailure is false', () => {
+      Cypress.config('isInteractive', false)
+      cy.stub(Screenshot, 'getConfig').returns({
+        screenshotOnRunFailure: false,
+      })
 
-      cy.spy(Cypress, "action").log(false);
+      cy.spy(Cypress, 'action').log(false)
 
       const test = {
-        err: new Error
-      };
+        err: new Error,
+      }
 
-      const runnable = cy.state("runnable");
+      const runnable = cy.state('runnable')
 
-      return Cypress.action("runner:runnable:after:run:async", test, runnable)
-      .then(function() {
-        expect(Cypress.action).not.to.be.calledWith("cy:test:set:state");
-        return expect(Cypress.automation).not.to.be.called;
-      });
-    });
+      Cypress.action('runner:runnable:after:run:async', test, runnable)
+      .then(() => {
+        expect(Cypress.action).not.to.be.calledWith('cy:test:set:state')
+        expect(Cypress.automation).not.to.be.called
+      })
+    })
 
-    it("sends before/after events", function() {
-      Cypress.config("isInteractive", false);
-      this.screenshotConfig.scale = false;
-      cy.stub(Screenshot, "getConfig").returns(this.screenshotConfig);
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
+    it('sends before/after events', function () {
+      Cypress.config('isInteractive', false)
+      this.screenshotConfig.scale = false
+      cy.stub(Screenshot, 'getConfig').returns(this.screenshotConfig)
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
 
-      cy.stub(Cypress, "action").log(false)
+      cy.stub(Cypress, 'action').log(false)
       .callThrough()
-      .withArgs("cy:before:screenshot")
-      .yieldsAsync();
+      .withArgs('cy:before:screenshot')
+      .yieldsAsync()
 
-      const test = { id: "123", err: new Error() };
-      const runnable = cy.state("runnable");
+      const test = { id: '123', err: new Error() }
+      const runnable = cy.state('runnable')
 
-      return Cypress.action("runner:runnable:after:run:async", test, runnable)
-      .then(function() {
-        expect(Cypress.action).to.be.calledWith("cy:before:screenshot", {
+      Cypress.action('runner:runnable:after:run:async', test, runnable)
+      .then(() => {
+        expect(Cypress.action).to.be.calledWith('cy:before:screenshot', {
           id: runnable.id,
           isOpen: true,
           appOnly: false,
           scale: true,
           waitForCommandSynchronization: true,
           disableTimersAndAnimations: true,
-          blackout: []
-        });
-        return expect(Cypress.action).to.be.calledWith("cy:after:screenshot", {
+          blackout: [],
+        })
+
+        expect(Cypress.action).to.be.calledWith('cy:after:screenshot', {
           id: runnable.id,
           isOpen: false,
           appOnly: false,
           scale: true,
           waitForCommandSynchronization: true,
           disableTimersAndAnimations: true,
-          blackout: []
-        });
-      });
-    });
+          blackout: [],
+        })
+      })
+    })
 
-    it("takes screenshot when not isInteractive", function() {
-      Cypress.config("isInteractive", false);
-      cy.stub(Screenshot, "getConfig").returns(this.screenshotConfig);
+    it('takes screenshot when not isInteractive', function () {
+      Cypress.config('isInteractive', false)
+      cy.stub(Screenshot, 'getConfig').returns(this.screenshotConfig)
 
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
 
       const test = {
-        id: "123",
-        err: new Error
-      };
-
-      const runnable = cy.state("runnable");
-
-      return Cypress.action("runner:runnable:after:run:async", test, runnable)
-      .then(function() {
-        expect(Cypress.automation).to.be.calledWith("take:screenshot");
-        let args = Cypress.automation.withArgs("take:screenshot").args[0][1];
-        args = _.omit(args, "padding", "clip", "userClip", "viewport", "takenPaths", "startTime");
-        return expect(args).to.eql({
+        id: '123',
+        err: new Error,
+      }
+
+      const runnable = cy.state('runnable')
+
+      Cypress.action('runner:runnable:after:run:async', test, runnable)
+      .then(() => {
+        expect(Cypress.automation).to.be.calledWith('take:screenshot')
+        let args = Cypress.automation.withArgs('take:screenshot').args[0][1]
+
+        args = _.omit(args, 'padding', 'clip', 'userClip', 'viewport', 'takenPaths', 'startTime')
+
+        expect(args).to.eql({
           testId: runnable.id,
           titles: [
-            "src/cy/commands/screenshot",
-            "runnable:after:run:async",
-            runnable.title
+            'src/cy/commands/screenshot',
+            'runnable:after:run:async',
+            runnable.title,
           ],
-          capture: "runner",
+          capture: 'runner',
           simple: true,
           testFailure: true,
           blackout: [],
-          scaled: true
-        });
-      });
-    });
+          scaled: true,
+        })
+      })
+    })
 
-    return describe("if screenshot has been taken in test", function() {
-      beforeEach(() => cy.state("screenshotTaken", true));
+    describe('if screenshot has been taken in test', () => {
+      beforeEach(() => {
+        cy.state('screenshotTaken', true)
+      })
 
-      return it("sends simple: false", function() {
-        Cypress.config("isInteractive", false);
-        cy.stub(Screenshot, "getConfig").returns(this.screenshotConfig);
+      it('sends simple: false', function () {
+        Cypress.config('isInteractive', false)
+        cy.stub(Screenshot, 'getConfig').returns(this.screenshotConfig)
 
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
 
         const test = {
-          id: "123",
-          err: new Error
-        };
-
-        const runnable = cy.state("runnable");
-
-        return Cypress.action("runner:runnable:after:run:async", test, runnable)
-        .then(function() {
-          expect(Cypress.automation.withArgs("take:screenshot")).to.be.calledOnce;
-          let args = Cypress.automation.withArgs("take:screenshot").args[0][1];
-          args = _.omit(args, "padding", "clip", "userClip", "viewport", "takenPaths", "startTime");
-          return expect(args).to.eql({
+          id: '123',
+          err: new Error,
+        }
+
+        const runnable = cy.state('runnable')
+
+        Cypress.action('runner:runnable:after:run:async', test, runnable)
+        .then(() => {
+          expect(Cypress.automation.withArgs('take:screenshot')).to.be.calledOnce
+          let args = Cypress.automation.withArgs('take:screenshot').args[0][1]
+
+          args = _.omit(args, 'padding', 'clip', 'userClip', 'viewport', 'takenPaths', 'startTime')
+
+          expect(args).to.eql({
             testId: runnable.id,
             titles: [
-              "src/cy/commands/screenshot",
-              "runnable:after:run:async",
-              "if screenshot has been taken in test",
-              runnable.title
+              'src/cy/commands/screenshot',
+              'runnable:after:run:async',
+              'if screenshot has been taken in test',
+              runnable.title,
             ],
-            capture: "runner",
+            capture: 'runner',
             testFailure: true,
             simple: false,
             scaled: true,
-            blackout: []
-          });
-        });
-      });
-    });
-  });
+            blackout: [],
+          })
+        })
+      })
+    })
+  })
 
-  context("runnable:after:run:async hooks", function() {
-    beforeEach(function() {
-      Cypress.config("isInteractive", false);
-      cy.stub(Screenshot, "getConfig").returns(this.screenshotConfig);
+  context('runnable:after:run:async hooks', () => {
+    beforeEach(function () {
+      Cypress.config('isInteractive', false)
+      cy.stub(Screenshot, 'getConfig').returns(this.screenshotConfig)
 
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
 
       const test = {
-        id: "123",
-        err: new Error
-      };
-      const runnable = cy.state("runnable");
-
-      return Cypress.action("runner:runnable:after:run:async", test, runnable)
-      .then(function() {
-        expect(Cypress.automation).to.be.calledWith("take:screenshot");
-        let args = Cypress.automation.withArgs("take:screenshot").args[0][1];
-        args = _.omit(args, "padding", "clip", "userClip", "viewport", "takenPaths", "startTime");
-        return expect(args).to.eql({
+        id: '123',
+        err: new Error,
+      }
+      const runnable = cy.state('runnable')
+
+      Cypress.action('runner:runnable:after:run:async', test, runnable)
+      .then(() => {
+        expect(Cypress.automation).to.be.calledWith('take:screenshot')
+        let args = Cypress.automation.withArgs('take:screenshot').args[0][1]
+
+        args = _.omit(args, 'padding', 'clip', 'userClip', 'viewport', 'takenPaths', 'startTime')
+
+        expect(args).to.eql({
           testId: runnable.id,
           titles: [
-            "src/cy/commands/screenshot",
-            "runnable:after:run:async hooks",
-            "takes screenshot of hook title with test",
-            '"before each" hook'
+            'src/cy/commands/screenshot',
+            'runnable:after:run:async hooks',
+            'takes screenshot of hook title with test',
+            '"before each" hook',
           ],
-          capture: "runner",
+          capture: 'runner',
           simple: true,
           testFailure: true,
           scaled: true,
-          blackout: []
-        });
-      });
-    });
-
-    return it("takes screenshot of hook title with test", function() {});
-  });
-
-  return context("#screenshot", function() {
-    beforeEach(function() {
-      return cy.stub(Screenshot, "getConfig").returns(this.screenshotConfig);
-    });
-
-    it("sets name to undefined when not passed name", function() {
-      const runnable = cy.state("runnable");
-      runnable.title = "foo bar";
-
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-
-      return cy.screenshot().then(() => expect(Cypress.automation.withArgs("take:screenshot").args[0][1].name).to.be.undefined);
-    });
-
-    it("can pass name", function() {
-      const runnable = cy.state("runnable");
-      runnable.title = "foo bar";
-
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-
-      return cy.screenshot("my/file").then(() => expect(Cypress.automation.withArgs("take:screenshot").args[0][1].name).to.equal("my/file"));
-    });
-
-    it("calls onBeforeScreenshot callback with documentElement", function() {
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      cy.stub(Screenshot, "onBeforeScreenshot");
-      cy.spy(Cypress, "action").log(false);
-
-      return cy
-      .screenshot("foo")
-      .then(function() {
-        expect(Screenshot.onBeforeScreenshot).to.be.calledOnce;
-        return expect(Screenshot.onBeforeScreenshot.firstCall.args[0].get(0)).to.eq(cy.state("document").documentElement);
-      });
-    });
-
-    it("calls onAfterScreenshot callback with documentElement", function() {
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      cy.stub(Screenshot, "onAfterScreenshot");
-      cy.spy(Cypress, "action").log(false);
-
-      return cy
-      .screenshot("foo")
-      .then(function() {
-        expect(Screenshot.onAfterScreenshot).to.be.calledOnce;
-        return expect(Screenshot.onAfterScreenshot.firstCall.args[0].get(0)).to.eq(cy.state("document").documentElement);
-      });
-    });
-
-    it("pauses then unpauses timers if disableTimersAndAnimations is true", function() {
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      cy.spy(Cypress, "action").log(false);
-      cy.spy(cy, "pauseTimers");
-
-      return cy
-      .screenshot("foo")
-      .then(function() {
-        expect(cy.pauseTimers).to.be.calledWith(true);
-        return expect(cy.pauseTimers).to.be.calledWith(false);
-      });
-    });
-
-    it("does not pause timers if disableTimersAndAnimations is false", function() {
-      this.screenshotConfig.disableTimersAndAnimations = false;
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      cy.spy(Cypress, "action").log(false);
-
-      return cy
-      .screenshot("foo")
-      .then(() => expect(Cypress.action.withArgs("cy:pause:timers")).not.to.be.called);
-    });
-
-    it("sends clip as userClip if specified", function() {
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      cy.spy(Cypress, "action").log(false);
-      const clip = { width: 100, height: 100, x: 0, y: 0 };
-
-      return cy
+          blackout: [],
+        })
+      })
+    })
+
+    it('takes screenshot of hook title with test', () => {})
+  })
+
+  context('#screenshot', () => {
+    beforeEach(function () {
+      cy.stub(Screenshot, 'getConfig').returns(this.screenshotConfig)
+    })
+
+    it('sets name to undefined when not passed name', function () {
+      const runnable = cy.state('runnable')
+
+      runnable.title = 'foo bar'
+
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+
+      cy.screenshot().then(() => {
+        expect(Cypress.automation.withArgs('take:screenshot').args[0][1].name).to.be.undefined
+      })
+    })
+
+    it('can pass name', function () {
+      const runnable = cy.state('runnable')
+
+      runnable.title = 'foo bar'
+
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+
+      cy.screenshot('my/file').then(() => {
+        expect(Cypress.automation.withArgs('take:screenshot').args[0][1].name).to.equal('my/file')
+      })
+    })
+
+    it('calls onBeforeScreenshot callback with documentElement', function () {
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      cy.stub(Screenshot, 'onBeforeScreenshot')
+      cy.spy(Cypress, 'action').log(false)
+
+      cy
+      .screenshot('foo')
+      .then(() => {
+        expect(Screenshot.onBeforeScreenshot).to.be.calledOnce
+        expect(Screenshot.onBeforeScreenshot.firstCall.args[0].get(0)).to.eq(cy.state('document').documentElement)
+      })
+    })
+
+    it('calls onAfterScreenshot callback with documentElement', function () {
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      cy.stub(Screenshot, 'onAfterScreenshot')
+      cy.spy(Cypress, 'action').log(false)
+
+      cy
+      .screenshot('foo')
+      .then(() => {
+        expect(Screenshot.onAfterScreenshot).to.be.calledOnce
+        expect(Screenshot.onAfterScreenshot.firstCall.args[0].get(0)).to.eq(cy.state('document').documentElement)
+      })
+    })
+
+    it('pauses then unpauses timers if disableTimersAndAnimations is true', function () {
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      cy.spy(Cypress, 'action').log(false)
+      cy.spy(cy, 'pauseTimers')
+
+      cy
+      .screenshot('foo')
+      .then(() => {
+        expect(cy.pauseTimers).to.be.calledWith(true)
+        expect(cy.pauseTimers).to.be.calledWith(false)
+      })
+    })
+
+    it('does not pause timers if disableTimersAndAnimations is false', function () {
+      this.screenshotConfig.disableTimersAndAnimations = false
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      cy.spy(Cypress, 'action').log(false)
+
+      cy
+      .screenshot('foo')
+      .then(() => {
+        expect(Cypress.action.withArgs('cy:pause:timers')).not.to.be.called
+      })
+    })
+
+    it('sends clip as userClip if specified', function () {
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      cy.spy(Cypress, 'action').log(false)
+      const clip = { width: 100, height: 100, x: 0, y: 0 }
+
+      cy
       .screenshot({ clip })
-      .then(() => expect(Cypress.automation.withArgs("take:screenshot").args[0][1].userClip).to.equal(clip));
-    });
+      .then(() => {
+        expect(Cypress.automation.withArgs('take:screenshot').args[0][1].userClip).to.equal(clip)
+      })
+    })
+
+    it('sends viewport dimensions of main browser window', function () {
+      Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      cy.spy(Cypress, 'action').log(false)
+
+      cy
+      .screenshot()
+      .then(() => {
+        expect(Cypress.automation.withArgs('take:screenshot').args[0][1].viewport).to.eql({
+          width: window.parent.innerWidth,
+          height: window.parent.innerHeight,
+        })
+      })
+    })
 
-    it("sends viewport dimensions of main browser window", function() {
-      Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      cy.spy(Cypress, "action").log(false);
+    it('can handle window w/length > 1 as a subject', () => {
+      cy.visit('/fixtures/dom.html')
 
-      return cy
+      cy.window().should('have.length.gt', 1)
       .screenshot()
-      .then(() => expect(Cypress.automation.withArgs("take:screenshot").args[0][1].viewport).to.eql({
-        width: window.parent.innerWidth,
-        height: window.parent.innerHeight
-      }));
-    });
-
-    it("can handle window w/length > 1 as a subject", function() {
-      cy.visit('/fixtures/dom.html');
-      return cy.window().should('have.length.gt', 1)
-      .screenshot();
-    });
-
-    describe("before/after events", function() {
-      beforeEach(function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-        return cy.spy(Cypress, "action").log(false);
-      });
-
-      it("sends before:screenshot", function() {
-        const runnable = cy.state("runnable");
-        return cy
-        .screenshot("foo")
-        .then(function() {
-          expect(Cypress.action.withArgs("cy:before:screenshot")).to.be.calledOnce;
-          return expect(Cypress.action.withArgs("cy:before:screenshot").args[0][1]).to.eql({
+    })
+
+    describe('before/after events', () => {
+      beforeEach(function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+
+        cy.spy(Cypress, 'action').log(false)
+      })
+
+      it('sends before:screenshot', () => {
+        const runnable = cy.state('runnable')
+
+        cy
+        .screenshot('foo')
+        .then(() => {
+          expect(Cypress.action.withArgs('cy:before:screenshot')).to.be.calledOnce
+          expect(Cypress.action.withArgs('cy:before:screenshot').args[0][1]).to.eql({
             id: runnable.id,
             isOpen: true,
             appOnly: true,
             scale: true,
             waitForCommandSynchronization: false,
             disableTimersAndAnimations: true,
-            blackout: [".foo"]
-          });
-        });
-      });
-
-      it("sends after:screenshot", function() {
-        const runnable = cy.state("runnable");
-        return cy
-        .screenshot("foo")
-        .then(function() {
-          expect(Cypress.action.withArgs("cy:after:screenshot")).to.be.calledOnce;
-          return expect(Cypress.action.withArgs("cy:after:screenshot").args[0][1]).to.eql({
+            blackout: ['.foo'],
+          })
+        })
+      })
+
+      it('sends after:screenshot', () => {
+        const runnable = cy.state('runnable')
+
+        cy
+        .screenshot('foo')
+        .then(() => {
+          expect(Cypress.action.withArgs('cy:after:screenshot')).to.be.calledOnce
+          expect(Cypress.action.withArgs('cy:after:screenshot').args[0][1]).to.eql({
             id: runnable.id,
             isOpen: false,
             appOnly: true,
             scale: true,
             waitForCommandSynchronization: false,
             disableTimersAndAnimations: true,
-            blackout: [".foo"]
-          });
-        });
-      });
-
-      it("always sends scale: true, waitForCommandSynchronization: true, and blackout: [] for non-app captures", function() {
-        const runnable = cy.state("runnable");
-        this.screenshotConfig.capture = "runner";
-        this.screenshotConfig.scale = false;
-
-        return cy
-        .screenshot("foo")
-        .then(() => expect(Cypress.action.withArgs("cy:before:screenshot").args[0][1]).to.eql({
-          id: runnable.id,
-          isOpen: true,
-          appOnly: false,
-          scale: true,
-          waitForCommandSynchronization: true,
-          disableTimersAndAnimations: true,
-          blackout: []
-        }));
-      });
+            blackout: ['.foo'],
+          })
+        })
+      })
 
-      return it("always sends waitForCommandSynchronization: false for viewport/fullPage captures", function() {
-        const runnable = cy.state("runnable");
-        this.screenshotConfig.waitForAnimations = true;
+      it('always sends scale: true, waitForCommandSynchronization: true, and blackout: [] for non-app captures', function () {
+        const runnable = cy.state('runnable')
 
-        return cy
-        .screenshot("foo")
-        .then(() => expect(Cypress.action.withArgs("cy:before:screenshot").args[0][1]).to.eql({
-          id: runnable.id,
-          isOpen: true,
-          appOnly: true,
-          scale: true,
-          waitForCommandSynchronization: false,
-          disableTimersAndAnimations: true,
-          blackout: [".foo"]
-        }));
-      });
-    });
-
-    describe("capture: fullPage", function() {
-      beforeEach(function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-        cy.spy(Cypress, "action").log(false);
-        cy.viewport(600, 200);
-        return cy.visit("/fixtures/screenshots.html");
-      });
-
-      it("takes a screenshot for each time it needs to scroll", () => cy.screenshot({ capture: "fullPage" })
-      .then(() => expect(Cypress.automation.withArgs("take:screenshot")).to.be.calledThrice));
-
-      it("sends capture: fullPage", () => cy.screenshot({ capture: "fullPage" })
-      .then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        expect(take.args[0][1].capture).to.equal("fullPage");
-        expect(take.args[1][1].capture).to.equal("fullPage");
-        return expect(take.args[2][1].capture).to.equal("fullPage");
-      }));
-
-      it("sends number of current screenshot for each time it needs to scroll", () => cy.screenshot({ capture: "fullPage" })
-      .then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        expect(take.args[0][1].current).to.equal(1);
-        expect(take.args[1][1].current).to.equal(2);
-        return expect(take.args[2][1].current).to.equal(3);
-      }));
-
-      it("sends total number of screenshots for each time it needs to scroll", () => cy.screenshot({ capture: "fullPage" })
-      .then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        expect(take.args[0][1].total).to.equal(3);
-        expect(take.args[1][1].total).to.equal(3);
-        return expect(take.args[2][1].total).to.equal(3);
-      }));
-
-      it("scrolls the window to the right place for each screenshot", function() {
-        const win = cy.state("window");
-        win.scrollTo(0, 100);
-        const scrollTo = cy.spy(win, "scrollTo");
-        return cy.screenshot({ capture: "fullPage" })
-        .then(function() {
-          expect(scrollTo.getCall(0).args.join(",")).to.equal("0,0");
-          expect(scrollTo.getCall(1).args.join(",")).to.equal("0,200");
-          return expect(scrollTo.getCall(2).args.join(",")).to.equal("0,400");
-        });
-      });
-
-      it("scrolls the window back to the original place", function() {
-        const win = cy.state("window");
-        win.scrollTo(0, 100);
-        const scrollTo = cy.spy(win, "scrollTo");
-        return cy.screenshot({ capture: "fullPage" })
-        .then(() => expect(scrollTo.getCall(3).args.join(",")).to.equal("0,100"));
-      });
-
-      return it("sends the right clip values", () => cy.screenshot({ capture: "fullPage" })
-      .then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        expect(take.args[0][1].clip).to.eql({ x: 0, y: 0, width: 600, height: 200 });
-        expect(take.args[1][1].clip).to.eql({ x: 0, y: 0, width: 600, height: 200 });
-        return expect(take.args[2][1].clip).to.eql({ x: 0, y: 120, width: 600, height: 80 });
-      }));
-    });
-
-    describe("element capture", function() {
-      beforeEach(function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-        cy.spy(Cypress, "action").log(false);
-        cy.viewport(600, 200);
-        return cy.visit("/fixtures/screenshots.html");
-      });
-
-      it("yields an object with details", function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-        cy.stub(Screenshot, "onAfterScreenshot");
-        cy.stub(Screenshot, "onBeforeScreenshot");
-
-        return cy
-        .get(".tall-element")
-        .screenshot("name", {
-          onBeforeScreenshot($el) {
-            return expect($el).to.match(".tall-element");
+        this.screenshotConfig.capture = 'runner'
+        this.screenshotConfig.scale = false
+
+        cy
+        .screenshot('foo')
+        .then(() => {
+          expect(Cypress.action.withArgs('cy:before:screenshot').args[0][1]).to.eql({
+            id: runnable.id,
+            isOpen: true,
+            appOnly: false,
+            scale: true,
+            waitForCommandSynchronization: true,
+            disableTimersAndAnimations: true,
+            blackout: [],
+          })
+        })
+      })
+
+      it('always sends waitForCommandSynchronization: false for viewport/fullPage captures', function () {
+        const runnable = cy.state('runnable')
+
+        this.screenshotConfig.waitForAnimations = true
+
+        cy
+        .screenshot('foo')
+        .then(() => {
+          expect(Cypress.action.withArgs('cy:before:screenshot').args[0][1]).to.eql({
+            id: runnable.id,
+            isOpen: true,
+            appOnly: true,
+            scale: true,
+            waitForCommandSynchronization: false,
+            disableTimersAndAnimations: true,
+            blackout: ['.foo'],
+          })
+        })
+      })
+    })
+
+    describe('capture: fullPage', () => {
+      beforeEach(function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+        cy.spy(Cypress, 'action').log(false)
+        cy.viewport(600, 200)
+        cy.visit('/fixtures/screenshots.html')
+      })
+
+      it('takes a screenshot for each time it needs to scroll', () => {
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          expect(Cypress.automation.withArgs('take:screenshot')).to.be.calledThrice
+        })
+      })
+
+      it('sends capture: fullPage', () => {
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].capture).to.equal('fullPage')
+          expect(take.args[1][1].capture).to.equal('fullPage')
+          expect(take.args[2][1].capture).to.equal('fullPage')
+        })
+      })
+
+      it('sends number of current screenshot for each time it needs to scroll', () => {
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].current).to.equal(1)
+          expect(take.args[1][1].current).to.equal(2)
+          expect(take.args[2][1].current).to.equal(3)
+        })
+      })
+
+      it('sends total number of screenshots for each time it needs to scroll', () => {
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].total).to.equal(3)
+          expect(take.args[1][1].total).to.equal(3)
+          expect(take.args[2][1].total).to.equal(3)
+        })
+      })
+
+      it('scrolls the window to the right place for each screenshot', () => {
+        const win = cy.state('window')
+
+        win.scrollTo(0, 100)
+        const scrollTo = cy.spy(win, 'scrollTo')
+
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          expect(scrollTo.getCall(0).args.join(',')).to.equal('0,0')
+          expect(scrollTo.getCall(1).args.join(',')).to.equal('0,200')
+          expect(scrollTo.getCall(2).args.join(',')).to.equal('0,400')
+        })
+      })
+
+      it('scrolls the window back to the original place', () => {
+        const win = cy.state('window')
+
+        win.scrollTo(0, 100)
+        const scrollTo = cy.spy(win, 'scrollTo')
+
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          expect(scrollTo.getCall(3).args.join(',')).to.equal('0,100')
+        })
+      })
+
+      it('sends the right clip values', () => {
+        cy.screenshot({ capture: 'fullPage' })
+        .then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].clip).to.eql({ x: 0, y: 0, width: 600, height: 200 })
+          expect(take.args[1][1].clip).to.eql({ x: 0, y: 0, width: 600, height: 200 })
+          expect(take.args[2][1].clip).to.eql({ x: 0, y: 120, width: 600, height: 80 })
+        })
+      })
+    })
+
+    describe('element capture', () => {
+      beforeEach(function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+        cy.spy(Cypress, 'action').log(false)
+        cy.viewport(600, 200)
+        cy.visit('/fixtures/screenshots.html')
+      })
+
+      it('yields an object with details', function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+        cy.stub(Screenshot, 'onAfterScreenshot')
+        cy.stub(Screenshot, 'onBeforeScreenshot')
+
+        cy
+        .get('.tall-element')
+        .screenshot('name', {
+          onBeforeScreenshot ($el) {
+            expect($el).to.match('.tall-element')
           },
 
-          onAfterScreenshot($el, results) {
-            expect($el).to.match(".tall-element");
-            expect(results).to.deep.eq(this.serverResult);
-            expect(results.name).to.eq("name");
-            expect(results.blackout).to.eql(this.screenshotConfig.blackout);
-            expect(results.dimensions).to.eql(this.serverResult.dimensions);
+          onAfterScreenshot ($el, results) {
+            expect($el).to.match('.tall-element')
+            expect(results).to.deep.eq(this.serverResult)
+            expect(results.name).to.eq('name')
+            expect(results.blackout).to.eql(this.screenshotConfig.blackout)
+            expect(results.dimensions).to.eql(this.serverResult.dimensions)
 
-            expect(Screenshot.onBeforeScreenshot).to.be.calledOnce;
-            expect(Screenshot.onBeforeScreenshot.firstCall.args[0]).to.match(".tall-element");
+            expect(Screenshot.onBeforeScreenshot).to.be.calledOnce
+            expect(Screenshot.onBeforeScreenshot.firstCall.args[0]).to.match('.tall-element')
+            expect(Screenshot.onAfterScreenshot).not.to.be.called
+          },
+        })
+        .then(() => {
+          expect(Screenshot.onAfterScreenshot).to.be.calledOnce
+          expect(Screenshot.onAfterScreenshot.firstCall.args[0]).to.match('.tall-element')
+        })
+      })
 
-            return expect(Screenshot.onAfterScreenshot).not.to.be.called;
-          }
+      it('takes a screenshot for each time it needs to scroll', () => {
+        cy.get('.tall-element').screenshot()
+        .then(() => {
+          expect(Cypress.automation.withArgs('take:screenshot')).to.be.calledTwice
+        })
+      })
+
+      it('sends number of current screenshot for each time it needs to scroll', () => {
+        cy.get('.tall-element').screenshot()
+        .then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].current).to.equal(1)
+          expect(take.args[1][1].current).to.equal(2)
+        })
+      })
+
+      it('sends total number of screenshots for each time it needs to scroll', () => {
+        cy.get('.tall-element').screenshot()
+        .then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].total).to.equal(2)
+          expect(take.args[1][1].total).to.equal(2)
+        })
+      })
+
+      it('scrolls the window to the right place for each screenshot', () => {
+        const win = cy.state('window')
+
+        win.scrollTo(0, 100)
+        const scrollTo = cy.spy(win, 'scrollTo')
+
+        cy.get('.tall-element').screenshot()
+        .then(() => {
+          expect(scrollTo.getCall(0).args.join(',')).to.equal('0,140')
+          expect(scrollTo.getCall(1).args.join(',')).to.equal('0,340')
+        })
+      })
+
+      it('scrolls the window back to the original place', () => {
+        const win = cy.state('window')
+
+        win.scrollTo(0, 100)
+        const scrollTo = cy.spy(win, 'scrollTo')
+
+        cy.get('.tall-element').screenshot()
+        .then(() => {
+          expect(scrollTo.getCall(2).args.join(',')).to.equal('0,100')
         })
-        .then(function() {
-          expect(Screenshot.onAfterScreenshot).to.be.calledOnce;
-          return expect(Screenshot.onAfterScreenshot.firstCall.args[0]).to.match(".tall-element");
-        });
-      });
-
-      it("takes a screenshot for each time it needs to scroll", () => cy.get(".tall-element").screenshot()
-      .then(() => expect(Cypress.automation.withArgs("take:screenshot")).to.be.calledTwice));
-
-      it("sends number of current screenshot for each time it needs to scroll", () => cy.get(".tall-element").screenshot()
-      .then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        expect(take.args[0][1].current).to.equal(1);
-        return expect(take.args[1][1].current).to.equal(2);
-      }));
-
-      it("sends total number of screenshots for each time it needs to scroll", () => cy.get(".tall-element").screenshot()
-      .then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        expect(take.args[0][1].total).to.equal(2);
-        return expect(take.args[1][1].total).to.equal(2);
-      }));
-
-      it("scrolls the window to the right place for each screenshot", function() {
-        const win = cy.state("window");
-        win.scrollTo(0, 100);
-        const scrollTo = cy.spy(win, "scrollTo");
-        return cy.get(".tall-element").screenshot()
-        .then(function() {
-          expect(scrollTo.getCall(0).args.join(",")).to.equal("0,140");
-          return expect(scrollTo.getCall(1).args.join(",")).to.equal("0,340");
-        });
-      });
-
-      it("scrolls the window back to the original place", function() {
-        const win = cy.state("window");
-        win.scrollTo(0, 100);
-        const scrollTo = cy.spy(win, "scrollTo");
-        return cy.get(".tall-element").screenshot()
-        .then(() => expect(scrollTo.getCall(2).args.join(",")).to.equal("0,100"));
-      });
-
-      it("sends the right clip values for elements that need scrolling", function() {
-        const scrollTo = cy.spy(cy.state("window"), "scrollTo");
-
-        return cy.get(".tall-element").screenshot()
-        .then(function() {
-          expect(scrollTo.getCall(0).args).to.eql([0, 140]);
-
-          const take = Cypress.automation.withArgs("take:screenshot");
-          expect(take.args[0][1].clip).to.eql({ x: 20, y: 0, width: 560, height: 200 });
-          return expect(take.args[1][1].clip).to.eql({ x: 20, y: 60, width: 560, height: 120 });
-        });
-      });
-
-      it("sends the right clip values for elements that don't need scrolling", function() {
-        const scrollTo = cy.spy(cy.state("window"), "scrollTo");
-
-        return cy.get(".short-element").screenshot()
-        .then(function() {
+      })
+
+      it('sends the right clip values for elements that need scrolling', () => {
+        const scrollTo = cy.spy(cy.state('window'), 'scrollTo')
+
+        cy.get('.tall-element').screenshot()
+        .then(() => {
+          expect(scrollTo.getCall(0).args).to.eql([0, 140])
+
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].clip).to.eql({ x: 20, y: 0, width: 560, height: 200 })
+          expect(take.args[1][1].clip).to.eql({ x: 20, y: 60, width: 560, height: 120 })
+        })
+      })
+
+      it('sends the right clip values for elements that don\'t need scrolling', () => {
+        const scrollTo = cy.spy(cy.state('window'), 'scrollTo')
+
+        cy.get('.short-element').screenshot()
+        .then(() => {
           // even though we don't need to scroll, the implementation behaviour is to
           // try to scroll until the element is at the top of the viewport.
-          expect(scrollTo.getCall(0).args).to.eql([0, 20]);
+          expect(scrollTo.getCall(0).args).to.eql([0, 20])
+
+          const take = Cypress.automation.withArgs('take:screenshot')
+
+          expect(take.args[0][1].clip).to.eql({ x: 40, y: 0, width: 200, height: 100 })
+        })
+      })
 
-          const take = Cypress.automation.withArgs("take:screenshot");
-          return expect(take.args[0][1].clip).to.eql({ x: 40, y: 0, width: 200, height: 100 });
-        });
-      });
+      it('applies padding to clip values for elements that need scrolling', () => {
+        const padding = 10
 
-      it("applies padding to clip values for elements that need scrolling", function() {
-        const padding = 10;
+        const scrollTo = cy.spy(cy.state('window'), 'scrollTo')
 
-        const scrollTo = cy.spy(cy.state("window"), "scrollTo");
+        cy.get('.tall-element').screenshot({ padding })
+        .then(() => {
+          const viewportHeight = getViewportHeight()
 
-        return cy.get(".tall-element").screenshot({ padding })
-        .then(function() {
-          const viewportHeight = getViewportHeight();
-          expect(scrollTo.getCall(0).args).to.eql([0, 140 - padding]);
-          expect(scrollTo.getCall(1).args).to.eql([0, (140 + viewportHeight) - padding ]);
+          expect(scrollTo.getCall(0).args).to.eql([0, 140 - padding])
+          expect(scrollTo.getCall(1).args).to.eql([0, (140 + viewportHeight) - padding])
 
-          const take = Cypress.automation.withArgs("take:screenshot");
+          const take = Cypress.automation.withArgs('take:screenshot')
 
           expect(take.args[0][1].clip).to.eql({
             x: 20 - padding,
             y: 0,
             width: 560 + (padding * 2),
-            height: viewportHeight
-          });
-          return expect(take.args[1][1].clip).to.eql({
+            height: viewportHeight,
+          })
+
+          expect(take.args[1][1].clip).to.eql({
             x: 20 - padding,
             y: 60 - padding,
             width: 560 + (padding * 2),
-            height: 120 + (padding * 2)
-          });
-        });
-      });
+            height: 120 + (padding * 2),
+          })
+        })
+      })
+
+      it('applies padding to clip values for elements that don\'t need scrolling', () => {
+        const padding = 10
 
-      it("applies padding to clip values for elements that don't need scrolling", function() {
-        const padding = 10;
+        const scrollTo = cy.spy(cy.state('window'), 'scrollTo')
 
-        const scrollTo = cy.spy(cy.state("window"), "scrollTo");
+        cy.get('.short-element').screenshot({ padding })
+        .then(() => {
+          expect(scrollTo.getCall(0).args).to.eql([0, padding])
 
-        return cy.get(".short-element").screenshot({ padding })
-        .then(function() {
-          expect(scrollTo.getCall(0).args).to.eql([0, padding]);
+          const take = Cypress.automation.withArgs('take:screenshot')
 
-          const take = Cypress.automation.withArgs("take:screenshot");
-          return expect(take.args[0][1].clip).to.eql({
+          expect(take.args[0][1].clip).to.eql({
             x: 30,
             y: 0,
             width: 220,
-            height: 120
-          });
-        });
-      });
-
-      it("works with cy.within()", () => cy.get(".short-element").within(() => cy.screenshot()).then(function() {
-        const take = Cypress.automation.withArgs("take:screenshot");
-        return expect(take.args[0][1].clip).to.eql({ x: 40, y: 0, width: 200, height: 100 });
-      }));
-
-      it("coerces capture option into 'app'", function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-
-        return cy.get(".short-element").screenshot({ capture: "runner" })
-        .then(function() {
-          expect(Cypress.action.withArgs("cy:before:screenshot").args[0][1].appOnly).to.be.true;
-          return expect(Cypress.automation.withArgs("take:screenshot").args[0][1].capture).to.equal("viewport");
-        });
-      });
-
-      it("passes through the existing $l subject", () => cy
-      .get(".short-element").then($el => cy
-      .get(".short-element")
-      .screenshot()
-      .then($el2 => {
-        return expect($el2.get(0)).to.equal($el.get(0));
-      })));
+            height: 120,
+          })
+        })
+      })
 
-      it("passes through window", () => cy
-      .window()
-      .then(win => cy.wrap(win)
-      .screenshot()
-      .then(w => expect(win === w).to.be.true)));
+      it('works with cy.within()', () => {
+        cy.get('.short-element').within(() => {
+          cy.screenshot()
+        }).then(() => {
+          const take = Cypress.automation.withArgs('take:screenshot')
 
-      return it("passes through document", () => cy
-      .document()
-      .then(doc => cy.wrap(doc)
-      .screenshot()
-      .then(d => expect(doc === d).to.be.true)));
-    });
+          expect(take.args[0][1].clip).to.eql({ x: 40, y: 0, width: 200, height: 100 })
+        })
+      })
 
-    describe("timeout", function() {
-      beforeEach(function() {
-        return Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-      });
+      it('coerces capture option into \'app\'', function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
 
-      it("sets timeout to Cypress.config(responseTimeout)", function() {
-        Cypress.config("responseTimeout", 2500);
+        cy.get('.short-element').screenshot({ capture: 'runner' })
+        .then(() => {
+          expect(Cypress.action.withArgs('cy:before:screenshot').args[0][1].appOnly).to.be.true
+          expect(Cypress.automation.withArgs('take:screenshot').args[0][1].capture).to.equal('viewport')
+        })
+      })
+
+      it('passes through the existing $l subject', () => {
+        cy
+        .get('.short-element').then(($el) => {
+          cy
+          .get('.short-element')
+          .screenshot()
+          .then(($el2) => {
+            expect($el2.get(0)).to.equal($el.get(0))
+          })
+        })
+      })
+
+      it('passes through window', () => {
+        cy
+        .window()
+        .then((win) => {
+          cy.wrap(win)
+          .screenshot()
+          .then((w) => {
+            expect(win === w).to.be.true
+          })
+        })
+      })
+
+      it('passes through document', () => {
+        cy
+        .document()
+        .then((doc) => {
+          cy.wrap(doc)
+          .screenshot()
+          .then((d) => {
+            expect(doc === d).to.be.true
+          })
+        })
+      })
+    })
 
-        const timeout = cy.spy(Promise.prototype, "timeout");
+    describe('timeout', () => {
+      beforeEach(function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+      })
 
-        return cy.screenshot().then(() => expect(timeout).to.be.calledWith(2500));
-      });
+      it('sets timeout to Cypress.config(responseTimeout)', () => {
+        Cypress.config('responseTimeout', 2500)
 
-      it("can override timeout", function() {
-        const timeout = cy.spy(Promise.prototype, "timeout");
+        const timeout = cy.spy(Promise.prototype, 'timeout')
 
-        return cy.screenshot({timeout: 1000}).then(() => expect(timeout).to.be.calledWith(1000));
-      });
+        cy.screenshot().then(() => {
+          expect(timeout).to.be.calledWith(2500)
+        })
+      })
 
-      it("can override timeout and pass name", function() {
-        const timeout = cy.spy(Promise.prototype, "timeout");
+      it('can override timeout', () => {
+        const timeout = cy.spy(Promise.prototype, 'timeout')
 
-        return cy.screenshot("foo", {timeout: 1000}).then(() => expect(timeout).to.be.calledWith(1000));
-      });
+        cy.screenshot({ timeout: 1000 }).then(() => {
+          expect(timeout).to.be.calledWith(1000)
+        })
+      })
 
-      return it("clears the current timeout and restores after success", function() {
-        cy.timeout(100);
+      it('can override timeout and pass name', () => {
+        const timeout = cy.spy(Promise.prototype, 'timeout')
 
-        cy.spy(cy, "clearTimeout");
+        cy.screenshot('foo', { timeout: 1000 }).then(() => {
+          expect(timeout).to.be.calledWith(1000)
+        })
+      })
 
-        return cy.screenshot().then(function() {
-          expect(cy.clearTimeout).to.be.calledWith("take:screenshot");
+      it('clears the current timeout and restores after success', () => {
+        cy.timeout(100)
 
-          //# restores the timeout afterwards
-          return expect(cy.timeout()).to.eq(100);
-        });
-      });
-    });
+        cy.spy(cy, 'clearTimeout')
 
-    describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 50);
+        cy.screenshot().then(() => {
+          expect(cy.clearTimeout).to.be.calledWith('take:screenshot')
 
-        this.logs = [];
+          // restores the timeout afterwards
+          expect(cy.timeout()).to.eq(100)
+        })
+      })
+    })
 
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "screenshot") {
-            this.lastLog = log;
-            return this.logs.push(log);
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'screenshot') {
+            this.lastLog = log
+            this.logs.push(log)
           }
-        });
-
-        this.assertErrorMessage = function(message, done) {
-          return cy.on("fail", err => {
-            const lastErr = this.lastLog.get("error");
-            expect(lastErr.message).to.eq(message);
-            return done();
-          });
-        };
-
-        return null;
-      });
-
-      it("throws if capture is not a string", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` `capture` option must be one of the following: `fullPage`, `viewport`, or `runner`. You passed: `true`");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-
-          return done();
-        });
-
-        return cy.screenshot({ capture: true });
-      });
-
-      it("throws if capture is not a valid option", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` `capture` option must be one of the following: `fullPage`, `viewport`, or `runner`. You passed: `foo`");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-
-          return done();
-        });
-
-        return cy.screenshot({ capture: "foo" });
-      });
-
-      it("throws if scale is not a boolean", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` `scale` option must be a boolean. You passed: `foo`");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-
-          return done();
-        });
-
-        return cy.screenshot({ scale: "foo" });
-      });
-
-      it("throws if disableTimersAndAnimations is not a boolean", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` `disableTimersAndAnimations` option must be a boolean. You passed: `foo`");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-
-          return done();
-        });
-
-        return cy.screenshot({ disableTimersAndAnimations: "foo" });
-      });
-
-      it("throws if blackout is not an array", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` `blackout` option must be an array of strings. You passed: `foo`");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-          return done();
-        });
-
-        return cy.screenshot({ blackout: "foo" });
-      });
-
-      it("throws if blackout is not an array of strings", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` `blackout` option must be an array of strings. You passed: `true`");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-          return done();
-        });
-
-        return cy.screenshot({ blackout: [true] });
-      });
-
-      it("throws if there is a 0px tall element height", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` only works with a screenshot area with a height greater than zero.", done);
-        cy.visit("/fixtures/screenshots.html");
-        return cy.get('.empty-element').screenshot();
-      });
-
-      it("throws if padding is not a number", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `padding` option must be either a number or an array of numbers with a maximum length of 4. You passed: `50px`", done);
-        return cy.screenshot({ padding: '50px' });
-      });
-
-      it("throws if padding is not an array of numbers", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `padding` option must be either a number or an array of numbers with a maximum length of 4. You passed: `bad, bad, bad, bad`", done);
-        return cy.screenshot({ padding: ['bad', 'bad', 'bad', 'bad'] });
-      });
-
-      it("throws if padding is not an array with a length between 1 and 4", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `padding` option must be either a number or an array of numbers with a maximum length of 4. You passed: `20, 10, 20, 10, 50`", done);
-        return cy.screenshot({ padding: [20, 10, 20, 10, 50] });
-      });
-
-      it("throws if padding is a large negative number that causes a 0px tall element height", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` only works with a screenshot area with a height greater than zero.", done);
-        cy.visit("/fixtures/screenshots.html");
-        return cy.get('.tall-element').screenshot({ padding: -161 });
-      });
-
-      it("throws if clip is not an object", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `true`", done);
-        return cy.screenshot({ clip: true });
-      });
-
-      it("throws if clip is lacking proper keys", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `{x: 5}`", done);
-        return cy.screenshot({ clip: { x: 5 } });
-      });
-
-      it("throws if clip has extraneous keys", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `Object{5}`", done);
-        return cy.screenshot({ clip: { width: 100, height: 100, x: 5, y: 5, foo: 10 } });
-      });
-
-      it("throws if clip has non-number values", function(done) {
-        this.assertErrorMessage("`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `Object{4}`", done);
-        return cy.screenshot({ clip: { width: 100, height: 100, x: 5, y: "5" } });
-      });
-
-      it("throws if element capture with multiple elements", function(done) {
-        cy.on("fail", err => {
-          const lastErr = this.lastLog.get("error");
-          expect(lastErr.message).to.eq("`cy.screenshot()` only works for a single element. You attempted to screenshot 4 elements.");
-          expect(lastErr.docsUrl).to.eq("https://on.cypress.io/screenshot");
-          return done();
-        });
-
-        cy.visit("/fixtures/screenshots.html");
-        return cy.get(".multiple").screenshot();
-      });
-
-      it("logs once on error", function(done) {
-        const error = new Error("some error");
-        error.name = "foo";
-        error.stack = "stack";
-
-        Cypress.automation.withArgs("take:screenshot").rejects(error);
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error").message).to.eq(error.message);
-          expect(lastLog.get("error").name).to.eq(error.name);
-          expect(lastLog.get("error").stack).to.eq(error.stack);
-          expect(lastLog.get("error")).to.eq(err);
-          return done();
-        });
-
-        return cy.screenshot();
-      });
-
-      return it("throws after timing out", function(done) {
-        Cypress.automation.withArgs("take:screenshot").resolves(Promise.delay(1000));
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("error")).to.eq(err);
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(lastLog.get("name")).to.eq("screenshot");
-          expect(lastLog.get("message")).to.eq("foo");
-          expect(err.message).to.eq("`cy.screenshot()` timed out waiting `50ms` to complete.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/screenshot");
-          return done();
-        });
-
-        return cy.screenshot("foo", {timeout: 50});
-      });
-    });
-
-    return describe(".log", function() {
-      beforeEach(function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
-
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "screenshot") {
-            return this.lastLog = log;
+        })
+
+        this.assertErrorMessage = function (message, done) {
+          cy.on('fail', (err) => {
+            const lastErr = this.lastLog.get('error')
+
+            expect(lastErr.message).to.eq(message)
+
+            done()
+          })
+        }
+
+        return null
+      })
+
+      it('throws if capture is not a string', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` `capture` option must be one of the following: `fullPage`, `viewport`, or `runner`. You passed: `true`')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot({ capture: true })
+      })
+
+      it('throws if capture is not a valid option', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` `capture` option must be one of the following: `fullPage`, `viewport`, or `runner`. You passed: `foo`')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot({ capture: 'foo' })
+      })
+
+      it('throws if scale is not a boolean', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` `scale` option must be a boolean. You passed: `foo`')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot({ scale: 'foo' })
+      })
+
+      it('throws if disableTimersAndAnimations is not a boolean', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` `disableTimersAndAnimations` option must be a boolean. You passed: `foo`')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot({ disableTimersAndAnimations: 'foo' })
+      })
+
+      it('throws if blackout is not an array', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` `blackout` option must be an array of strings. You passed: `foo`')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot({ blackout: 'foo' })
+      })
+
+      it('throws if blackout is not an array of strings', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` `blackout` option must be an array of strings. You passed: `true`')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot({ blackout: [true] })
+      })
+
+      it('throws if there is a 0px tall element height', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` only works with a screenshot area with a height greater than zero.', done)
+        cy.visit('/fixtures/screenshots.html')
+
+        cy.get('.empty-element').screenshot()
+      })
+
+      it('throws if padding is not a number', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `padding` option must be either a number or an array of numbers with a maximum length of 4. You passed: `50px`', done)
+
+        cy.screenshot({ padding: '50px' })
+      })
+
+      it('throws if padding is not an array of numbers', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `padding` option must be either a number or an array of numbers with a maximum length of 4. You passed: `bad, bad, bad, bad`', done)
+
+        cy.screenshot({ padding: ['bad', 'bad', 'bad', 'bad'] })
+      })
+
+      it('throws if padding is not an array with a length between 1 and 4', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `padding` option must be either a number or an array of numbers with a maximum length of 4. You passed: `20, 10, 20, 10, 50`', done)
+
+        cy.screenshot({ padding: [20, 10, 20, 10, 50] })
+      })
+
+      it('throws if padding is a large negative number that causes a 0px tall element height', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` only works with a screenshot area with a height greater than zero.', done)
+        cy.visit('/fixtures/screenshots.html')
+
+        cy.get('.tall-element').screenshot({ padding: -161 })
+      })
+
+      it('throws if clip is not an object', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `true`', done)
+
+        cy.screenshot({ clip: true })
+      })
+
+      it('throws if clip is lacking proper keys', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `{x: 5}`', done)
+
+        cy.screenshot({ clip: { x: 5 } })
+      })
+
+      it('throws if clip has extraneous keys', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `Object{5}`', done)
+
+        cy.screenshot({ clip: { width: 100, height: 100, x: 5, y: 5, foo: 10 } })
+      })
+
+      it('throws if clip has non-number values', function (done) {
+        this.assertErrorMessage('`cy.screenshot()` `clip` option must be an object with the keys `{ width, height, x, y }` and number values. You passed: `Object{4}`', done)
+
+        cy.screenshot({ clip: { width: 100, height: 100, x: 5, y: '5' } })
+      })
+
+      it('throws if element capture with multiple elements', function (done) {
+        cy.on('fail', (err) => {
+          const lastErr = this.lastLog.get('error')
+
+          expect(lastErr.message).to.eq('`cy.screenshot()` only works for a single element. You attempted to screenshot 4 elements.')
+          expect(lastErr.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.visit('/fixtures/screenshots.html')
+
+        cy.get('.multiple').screenshot()
+      })
+
+      it('logs once on error', function (done) {
+        const error = new Error('some error')
+
+        error.name = 'foo'
+        error.stack = 'stack'
+
+        Cypress.automation.withArgs('take:screenshot').rejects(error)
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error').message).to.eq(error.message)
+          expect(lastLog.get('error').name).to.eq(error.name)
+          expect(lastLog.get('error').stack).to.eq(error.stack)
+          expect(lastLog.get('error')).to.eq(err)
+
+          done()
+        })
+
+        cy.screenshot()
+      })
+
+      it('throws after timing out', function (done) {
+        Cypress.automation.withArgs('take:screenshot').resolves(Promise.delay(1000))
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(lastLog.get('name')).to.eq('screenshot')
+          expect(lastLog.get('message')).to.eq('foo')
+          expect(err.message).to.eq('`cy.screenshot()` timed out waiting `50ms` to complete.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/screenshot')
+
+          done()
+        })
+
+        cy.screenshot('foo', { timeout: 50 })
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'screenshot') {
+            this.lastLog = log
           }
-        });
+        })
 
-        return null;
-      });
+        return null
+      })
 
-      it("can turn off logging", () => cy.screenshot("bar", {log: false}).then(function() {
-        return expect(this.lastLog).to.be.undefined;
-      }));
+      it('can turn off logging', () => {
+        cy.screenshot('bar', { log: false }).then(function () {
+          expect(this.lastLog).to.be.undefined
+        })
+      })
 
-      it("ends immediately", () => cy.screenshot().then(function() {
-        const {
-          lastLog
-        } = this;
+      it('ends immediately', () => {
+        cy.screenshot().then(function () {
+          const { lastLog } = this
 
-        expect(lastLog.get("ended")).to.be.true;
-        return expect(lastLog.get("state")).to.eq("passed");
-      }));
+          expect(lastLog.get('ended')).to.be.true
+          expect(lastLog.get('state')).to.eq('passed')
+        })
+      })
 
-      it("snapshots immediately", () => cy.screenshot().then(function() {
-        const {
-          lastLog
-        } = this;
+      it('snapshots immediately', () => {
+        cy.screenshot().then(function () {
+          const { lastLog } = this
 
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      }));
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
 
-      return it("#consoleProps", function() {
-        Cypress.automation.withArgs("take:screenshot").resolves(this.serverResult);
+      it('#consoleProps', function () {
+        Cypress.automation.withArgs('take:screenshot').resolves(this.serverResult)
 
         let expected = _.extend({}, this.serverResult, this.screenshotConfig, {
-          Command: "screenshot",
+          Command: 'screenshot',
           scaled: true,
-          duration: "100ms"
-        });
-
-        expected = _.omit(expected, "blackout", "dimensions", "screenshotOnRunFailure", "scale", "size");
-
-        return cy.screenshot().then(() => {
-          const consoleProps = this.lastLog.invoke("consoleProps");
-          const actual = _.omit(consoleProps, "blackout", "dimensions", "size");
-          const { width, height } = this.serverResult.dimensions;
-          expect(actual).to.eql(expected);
-          expect(consoleProps.size).to.eq("12 B");
-          expect(consoleProps.blackout).to.eql(this.screenshotConfig.blackout);
-          return expect(consoleProps.dimensions).to.equal(`${width}px x ${height}px`);
-        });
-      });
-    });
-  });
-});
+          duration: '100ms',
+        })
+
+        expected = _.omit(expected, 'blackout', 'dimensions', 'screenshotOnRunFailure', 'scale', 'size')
+
+        cy.screenshot().then(() => {
+          const consoleProps = this.lastLog.invoke('consoleProps')
+          const actual = _.omit(consoleProps, 'blackout', 'dimensions', 'size')
+          const { width, height } = this.serverResult.dimensions
+
+          expect(actual).to.eql(expected)
+          expect(consoleProps.size).to.eq('12 B')
+          expect(consoleProps.blackout).to.eql(this.screenshotConfig.blackout)
+          expect(consoleProps.dimensions).to.equal(`${width}px x ${height}px`)
+        })
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/task_spec.js b/packages/driver/test/cypress/integration/commands/task_spec.js
index ef7e7159db16..8efb8540290d 100644
--- a/packages/driver/test/cypress/integration/commands/task_spec.js
+++ b/packages/driver/test/cypress/integration/commands/task_spec.js
@@ -1,271 +1,278 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const {
-  _
-} = Cypress;
-const {
-  Promise
-} = Cypress;
-
-describe("src/cy/commands/task", () => context("#task", function() {
-  beforeEach(function() {
-    Cypress.config("taskTimeout", 2500);
-
-    return cy.stub(Cypress, "backend").callThrough();
-  });
-
-  it("calls Cypress.backend('task') with the right options", function() {
-    Cypress.backend.resolves(null);
-
-    return cy.task("foo").then(() => expect(Cypress.backend).to.be.calledWith("task", {
-      task: "foo",
-      timeout: 2500,
-      arg: undefined
-    }));
-  });
-
-  it("passes through arg", function() {
-    Cypress.backend.resolves(null);
-
-    return cy.task("foo", { foo: "foo" }).then(() => expect(Cypress.backend).to.be.calledWith("task", {
-      task: "foo",
-      timeout: 2500,
-      arg: {
-        foo: "foo"
-      }
-    }));
-  });
-
-  it("really works", () => cy.task("return:arg", "works").should("eq", "works"));
-
-  describe(".log", function() {
-    beforeEach(function() {
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        this.lastLog = log;
-        return this.logs.push(log);
-      });
-
-      Cypress.backend.resolves(null);
-
-      return null;
-    });
-
-    it("can turn off logging", () => cy.task("foo", null, { log: false }).then(function() {
-      const logs = _.filter(this.logs, log => log.get("name") === "task");
-
-      return expect(logs.length).to.eq(0);
-    }));
-
-    return it("logs immediately before resolving", function() {
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "task") {
-          expect(log.get("state")).to.eq("pending");
-          return expect(log.get("message")).to.eq("foo");
-        }
-      });
-
-      return cy.task("foo").then(() => {
-        if (!this.lastLog) { throw new Error("failed to log before resolving"); }
-      });
-    });
-  });
-
-  describe("timeout", function() {
-    beforeEach(() => Cypress.backend.resolves(null));
-
-    it("defaults timeout to Cypress.config(taskTimeout)", function() {
-      const timeout = cy.spy(Promise.prototype, "timeout");
-
-      return cy.task("foo").then(() => expect(timeout).to.be.calledWith(2500));
-    });
-
-    it("can override timeout", function() {
-      const timeout = cy.spy(Promise.prototype, "timeout");
-
-      return cy.task("foo", null, { timeout: 1000 }).then(() => expect(timeout).to.be.calledWith(1000));
-    });
-
-    return it("clears the current timeout and restores after success", function() {
-      cy.timeout(100);
-
-      const clearTimeout = cy.spy(cy, "clearTimeout");
-
-      cy.on("task", () => {
-        return expect(clearTimeout).to.be.calledOnce;
-      });
-
-      return cy.task("foo").then(() => expect(cy.timeout()).to.eq(100));
-    });
-  });
-
-  return describe("errors", function() {
-    beforeEach(function() {
-      Cypress.config("defaultCommandTimeout", 50);
-
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "task") {
-          this.lastLog = log;
-          return this.logs.push(log);
-        }
-      });
-
-      return null;
-    });
-
-    it("throws when task is absent", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.task()` must be passed a non-empty string as its 1st argument. You passed: ``.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/task");
-        return done();
-      });
-
-      return cy.task();
-    });
-
-    it("throws when task isn't a string", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.task()` must be passed a non-empty string as its 1st argument. You passed: `3`.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/task");
-        return done();
-      });
-
-      return cy.task(3);
-    });
-
-    it("throws when task is an empty string", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.task()` must be passed a non-empty string as its 1st argument. You passed: ``.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/task");
-        return done();
-      });
-
-      return cy.task('');
-    });
-
-    it("throws when the task errors", function(done) {
-      Cypress.backend.rejects(new Error("task failed"));
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-
-        expect(err.message).to.include("`cy.task('foo')` failed with the following error:");
-        expect(err.message).to.include("> task failed");
-        return done();
-      });
-
-      return cy.task("foo");
-    });
-
-    it("throws when task is not registered by plugin", function(done) {
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-
-        expect(err.message).to.eq(`\`cy.task('bar')\` failed with the following error:\n\nThe task 'bar' was not handled in the plugins file. The following tasks are registered: return:arg, wait, create:long:file\n\nFix this in your plugins file here:\n${Cypress.config('pluginsFile')}\n\nhttps://on.cypress.io/api/task`);
-        return done();
-      });
-
-      return cy.task("bar");
-    });
-
-    it("throws after timing out", function(done) {
-      Cypress.backend.resolves(Promise.delay(250));
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        expect(err.message).to.eq("`cy.task('foo')` timed out after waiting `50ms`.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/task");
-        return done();
-      });
-
-      return cy.task("foo", null, { timeout: 50 });
-    });
-
-    it("logs once on error", function(done) {
-      Cypress.backend.rejects(new Error("task failed"));
-
-      cy.on("fail", err => {
-        const {
-          lastLog
-        } = this;
-
-        expect(this.logs.length).to.eq(1);
-        expect(lastLog.get("error")).to.eq(err);
-        expect(lastLog.get("state")).to.eq("failed");
-        return done();
-      });
-
-      return cy.task("foo");
-    });
-
-    it("can timeout from the backend's response", function(done) {
-      const err = new Error("timeout");
-      err.timedOut = true;
-
-      Cypress.backend.rejects(err);
-
-      cy.on("fail", function(err) {
-        expect(err.message).to.include("`cy.task('wait')` timed out after waiting `100ms`.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/task");
-        return done();
-      });
-
-      return cy.task("wait", null, { timeout: 100 });
-    });
-
-    return it("can really time out", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.include("`cy.task('wait')` timed out after waiting `100ms`.");
-        expect(err.docsUrl).to.eq("https://on.cypress.io/task");
-        return done();
-      });
-
-      return cy.task("wait", null, { timeout: 100 });
-    });
-  });
-}));
+const { _, Promise } = Cypress
+
+describe('src/cy/commands/task', () => {
+  context('#task', () => {
+    beforeEach(() => {
+      Cypress.config('taskTimeout', 2500)
+      cy.stub(Cypress, 'backend').callThrough()
+    })
+
+    it('calls Cypress.backend(\'task\') with the right options', () => {
+      Cypress.backend.resolves(null)
+
+      cy.task('foo').then(() => {
+        expect(Cypress.backend).to.be.calledWith('task', {
+          task: 'foo',
+          timeout: 2500,
+          arg: undefined,
+        })
+      })
+    })
+
+    it('passes through arg', () => {
+      Cypress.backend.resolves(null)
+
+      cy.task('foo', { foo: 'foo' }).then(() => {
+        expect(Cypress.backend).to.be.calledWith('task', {
+          task: 'foo',
+          timeout: 2500,
+          arg: {
+            foo: 'foo',
+          },
+        })
+      })
+    })
+
+    it('really works', () => {
+      cy.task('return:arg', 'works').should('eq', 'works')
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        Cypress.backend.resolves(null)
+
+        return null
+      })
+
+      it('can turn off logging', () => {
+        cy.task('foo', null, { log: false }).then(function () {
+          const logs = _.filter(this.logs, (log) => {
+            return log.get('name') === 'task'
+          })
+
+          expect(logs.length).to.eq(0)
+        })
+      })
+
+      it('logs immediately before resolving', function () {
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'task') {
+            expect(log.get('state')).to.eq('pending')
+            expect(log.get('message')).to.eq('foo')
+          }
+        })
+
+        cy.task('foo').then(() => {
+          if (!this.lastLog) {
+            throw new Error('failed to log before resolving')
+          }
+        })
+      })
+    })
+
+    describe('timeout', () => {
+      beforeEach(() => {
+        Cypress.backend.resolves(null)
+      })
+
+      it('defaults timeout to Cypress.config(taskTimeout)', () => {
+        const timeout = cy.spy(Promise.prototype, 'timeout')
+
+        cy.task('foo').then(() => {
+          expect(timeout).to.be.calledWith(2500)
+        })
+      })
+
+      it('can override timeout', () => {
+        const timeout = cy.spy(Promise.prototype, 'timeout')
+
+        cy.task('foo', null, { timeout: 1000 }).then(() => {
+          expect(timeout).to.be.calledWith(1000)
+        })
+      })
+
+      it('clears the current timeout and restores after success', () => {
+        cy.timeout(100)
+
+        const clearTimeout = cy.spy(cy, 'clearTimeout')
+
+        cy.on('task', () => {
+          expect(clearTimeout).to.be.calledOnce
+        })
+
+        cy.task('foo').then(() => {
+          expect(cy.timeout()).to.eq(100)
+        })
+      })
+    })
+
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'task') {
+            this.lastLog = log
+            this.logs.push(log)
+          }
+        })
+
+        return null
+      })
+
+      it('throws when task is absent', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.task()` must be passed a non-empty string as its 1st argument. You passed: ``.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/task')
+
+          done()
+        })
+
+        cy.task()
+      })
+
+      it('throws when task isn\'t a string', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.task()` must be passed a non-empty string as its 1st argument. You passed: `3`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/task')
+
+          done()
+        })
+
+        cy.task(3)
+      })
+
+      it('throws when task is an empty string', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.task()` must be passed a non-empty string as its 1st argument. You passed: ``.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/task')
+
+          done()
+        })
+
+        cy.task('')
+      })
+
+      it('throws when the task errors', function (done) {
+        Cypress.backend.rejects(new Error('task failed'))
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+
+          expect(err.message).to.include('`cy.task(\'foo\')` failed with the following error:')
+          expect(err.message).to.include('> task failed')
+
+          done()
+        })
+
+        cy.task('foo')
+      })
+
+      it('throws when task is not registered by plugin', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+
+          expect(err.message).to.eq(`\`cy.task('bar')\` failed with the following error:\n\nThe task 'bar' was not handled in the plugins file. The following tasks are registered: return:arg, wait, create:long:file\n\nFix this in your plugins file here:\n${Cypress.config('pluginsFile')}\n\nhttps://on.cypress.io/api/task`)
+
+          done()
+        })
+
+        cy.task('bar')
+      })
+
+      it('throws after timing out', function (done) {
+        Cypress.backend.resolves(Promise.delay(250))
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(err.message).to.eq('`cy.task(\'foo\')` timed out after waiting `50ms`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/task')
+
+          done()
+        })
+
+        cy.task('foo', null, { timeout: 50 })
+      })
+
+      it('logs once on error', function (done) {
+        Cypress.backend.rejects(new Error('task failed'))
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('state')).to.eq('failed')
+
+          done()
+        })
+
+        cy.task('foo')
+      })
+
+      it('can timeout from the backend\'s response', (done) => {
+        const err = new Error('timeout')
+
+        err.timedOut = true
+
+        Cypress.backend.rejects(err)
+
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.task(\'wait\')` timed out after waiting `100ms`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/task')
+
+          done()
+        })
+
+        cy.task('wait', null, { timeout: 100 })
+      })
+
+      it('can really time out', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.task(\'wait\')` timed out after waiting `100ms`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/task')
+
+          done()
+        })
+
+        cy.task('wait', null, { timeout: 100 })
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/traversals_spec.js b/packages/driver/test/cypress/integration/commands/traversals_spec.js
index 8c862ecdea51..ade1f6fbc53a 100644
--- a/packages/driver/test/cypress/integration/commands/traversals_spec.js
+++ b/packages/driver/test/cypress/integration/commands/traversals_spec.js
@@ -1,337 +1,368 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const $ = Cypress.$.bind(Cypress);
-const {
-  _
-} = Cypress;
-const {
-  dom
-} = Cypress;
-
-const helpers = require("../../support/helpers");
-
-describe("src/cy/commands/traversals", function() {
-  beforeEach(() => cy.visit("/fixtures/dom.html"));
+const $ = Cypress.$.bind(Cypress)
+const { _, dom } = Cypress
+
+const helpers = require('../../support/helpers')
+
+describe('src/cy/commands/traversals', () => {
+  beforeEach(() => {
+    cy.visit('/fixtures/dom.html')
+  })
 
   const fns = [
-    {find: "*"},
-    {filter: ":first"},
-    {filter(i) { return i === 0; }},
-    {not: "div"},
-    {not(i, e) { return e.tagName === 'div'; }},
-    {eq: 0},
-    {closest: "body"},
-    "children", "first", "last", "next", "nextAll", "nextUntil", "parent", "parents", "parentsUntil", "prev", "prevAll", "prevUntil", "siblings"
-  ];
-  _.each(fns, function(fn) {
-    //# normalize string vs object
-    let arg, name;
+    { find: '*' },
+    { filter: ':first' },
+    { filter: (i) => i === 0 },
+    { not: 'div' },
+    { not: (i, e) => e.tagName === 'div' },
+    { eq: 0 },
+    { closest: 'body' },
+    'children', 'first', 'last', 'next', 'nextAll', 'nextUntil', 'parent', 'parents', 'parentsUntil', 'prev', 'prevAll', 'prevUntil', 'siblings',
+  ]
+
+  _.each(fns, (fn) => {
+    // normalize string vs object
+    let arg
+    let name
+
     if (_.isObject(fn)) {
-      name = _.keys(fn)[0];
-      arg = fn[name];
+      name = _.keys(fn)[0]
+      arg = fn[name]
     } else {
-      name = fn;
+      name = fn
     }
 
-    return context(`#${name}`, function() {
-      it("proxies through to jquery and returns new subject", function() {
-        const el = cy.$$("#list")[name](arg);
-        return cy.get("#list")[name](arg).then($el => expect($el).to.match(el));
-      });
+    context(`#${name}`, () => {
+      it('proxies through to jquery and returns new subject', () => {
+        const el = cy.$$('#list')[name](arg)
+
+        cy.get('#list')[name](arg).then(($el) => {
+          expect($el).to.match(el)
+        })
+      })
+
+      describe('errors', () => {
+        beforeEach(() => {
+          Cypress.config('defaultCommandTimeout', 100)
+        })
 
-      describe("errors", function() {
-        beforeEach(() => Cypress.config("defaultCommandTimeout", 100));
+        it('throws when options.length isnt a number', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('You must provide a valid number to a `length` assertion. You passed: `asdf`')
 
-        it("throws when options.length isnt a number", function(done) {
-          cy.on("fail", function(err) {
-            expect(err.message).to.include("You must provide a valid number to a `length` assertion. You passed: `asdf`");
-            return done();
-          });
+            done()
+          })
 
-          return cy.get("#list")[name](arg).should("have.length", "asdf");
-        });
+          cy.get('#list')[name](arg).should('have.length', 'asdf')
+        })
 
-        it("throws on too many elements after timing out waiting for length", function(done) {
-          const el = cy.$$("#list")[name](arg);
+        it('throws on too many elements after timing out waiting for length', (done) => {
+          const el = cy.$$('#list')[name](arg)
 
-          const node = dom.stringify(cy.$$("#list"), "short");
+          dom.stringify(cy.$$('#list'), 'short')
 
-          cy.on("fail", function(err) {
-            expect(err.message).to.include(`Too many elements found. Found '${el.length}', expected '${el.length - 1}'.`);
-            return done();
-          });
+          cy.on('fail', (err) => {
+            expect(err.message).to.include(`Too many elements found. Found '${el.length}', expected '${el.length - 1}'.`)
 
-          return cy.get("#list")[name](arg).should("have.length", el.length - 1);
-        });
+            done()
+          })
 
-        it("throws on too few elements after timing out waiting for length", function(done) {
-          const el = cy.$$("#list")[name](arg);
+          cy.get('#list')[name](arg).should('have.length', el.length - 1)
+        })
 
-          const node = dom.stringify(cy.$$("#list"), "short");
+        it('throws on too few elements after timing out waiting for length', (done) => {
+          const el = cy.$$('#list')[name](arg)
 
-          cy.on("fail", function(err) {
-            expect(err.message).to.include(`Not enough elements found. Found '${el.length}', expected '${el.length + 1}'.`);
-            return done();
-          });
+          dom.stringify(cy.$$('#list'), 'short')
 
-          return cy.get("#list")[name](arg).should("have.length", el.length + 1);
-        });
+          cy.on('fail', (err) => {
+            expect(err.message).to.include(`Not enough elements found. Found '${el.length}', expected '${el.length + 1}'.`)
 
-        it("without a dom element", function(done) {
-          cy.on("fail", () => done());
-          return cy.noop({})[name](arg);
-        });
+            done()
+          })
 
-        it("throws when subject is not in the document", function(done) {
-          cy.on("command:end", () => {
-            return cy.$$("#list").remove();
-          });
+          cy.get('#list')[name](arg).should('have.length', el.length + 1)
+        })
 
-          cy.on("fail", function(err) {
-            expect(err.message).to.include(`\`cy.${name}()\` failed because this element`);
-            return done();
-          });
+        it('without a dom element', (done) => {
+          cy.on('fail', () => {
+            done()
+          })
 
-          return cy.get("#list")[name](arg);
-        });
+          cy.noop({})[name](arg)
+        })
 
-        return it("returns no elements", function(done) {
+        it('throws when subject is not in the document', (done) => {
+          cy.on('command:end', () => {
+            cy.$$('#list').remove()
+          })
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include(`\`cy.${name}()\` failed because this element`)
+
+            done()
+          })
+
+          cy.get('#list')[name](arg)
+        })
+
+        it('returns no elements', (done) => {
           const errIncludes = (el, node) => {
-            node = dom.stringify(cy.$$(node), "short");
+            node = dom.stringify(cy.$$(node), 'short')
+
+            cy.on('fail', (err) => {
+              expect(err.message).to.include(`Expected to find element: \`${el}\`, but never found it. Queried from element: ${node}`)
 
-            return cy.on("fail", function(err) {
-              expect(err.message).to.include(`Expected to find element: \`${el}\`, but never found it. Queried from element: ${node}`);
-              return done();
-            });
-          };
+              done()
+            })
+          }
 
           switch (name) {
-            case "not":
-              errIncludes(":checkbox", ":checkbox");
-              return cy.get(":checkbox").not(":checkbox");
+            case 'not':
+              errIncludes(':checkbox', ':checkbox')
+
+              cy.get(':checkbox').not(':checkbox')
+
+              break
 
-            //# these cannot error
-            case "first": case "last": case "parentsUntil": return done();
+            // these cannot error
+            case 'first':
+            case 'last':
+            case 'parentsUntil':
+              done()
+              break
 
             default:
-              errIncludes(".no-class-like-this-exists", "div:first");
-              return cy.get("div:first")[name](".no-class-like-this-exists");
+              errIncludes('.no-class-like-this-exists', 'div:first')
+
+              cy.get('div:first')[name]('.no-class-like-this-exists')
+
+              break
           }
-        });
-      });
-
-      return describe(".log", function() {
-        beforeEach(function() {
-          cy.on("log:added", (attrs, log) => {
-            return this.lastLog = log;
-          });
-
-          return null;
-        });
-
-        it("logs immediately before resolving", function(done) {
-          cy.on("log:added", function(attrs, log) {
-            if (log.get("name") === name) {
-              expect(log.pick("state")).to.deep.eq({
-                state: "pending"
-              });
-              return done();
+        })
+      })
+
+      describe('.log', () => {
+        beforeEach(function () {
+          cy.on('log:added', (attrs, log) => {
+            this.lastLog = log
+          })
+
+          return null
+        })
+
+        it('logs immediately before resolving', (done) => {
+          cy.on('log:added', (attrs, log) => {
+            if (log.get('name') === name) {
+              expect(log.pick('state')).to.deep.eq({
+                state: 'pending',
+              })
+
+              done()
             }
-          });
-
-          return cy.get("#list")[name](arg);
-        });
-
-        it("snapshots after finding element", () => cy.get("#list")[name](arg).then(function() {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("snapshots").length).to.eq(1);
-          return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-        }));
-
-        it("has the $el", () => cy.get("#list")[name](arg).then(function($el) {
-          const {
-            lastLog
-          } = this;
-
-          return expect(lastLog.get("$el").get(0)).to.eq($el.get(0));
-        }));
-
-        it("has a custom message", () => cy.get("#list")[name](arg).then(function() {
-          let message;
-          if (_.isUndefined(arg) || _.isFunction(arg)) {
-            message = "";
-          } else {
-            message = arg.toString();
-          }
-
-          const {
-            lastLog
-          } = this;
+          })
 
-          return expect(lastLog.get("message")).to.eq(message);
-        }));
+          cy.get('#list')[name](arg)
+        })
 
-        it("#consoleProps", () => cy.get("#list")[name](arg).then(function($el) {
-          const obj = {Command: name};
-          if (_.isFunction(arg)) {
-            obj.Selector = "";
-          } else {
-            obj.Selector = [].concat(arg).join(", ");
-          }
+        it('snapshots after finding element', () => {
+          cy.get('#list')[name](arg).then(function () {
+            const { lastLog } = this
 
-          const yielded = Cypress.dom.getElements($el);
+            expect(lastLog.get('snapshots').length).to.eq(1)
+            expect(lastLog.get('snapshots')[0]).to.be.an('object')
+          })
+        })
 
-          _.extend(obj, {
-            "Applied To": helpers.getFirstSubjectByName("get").get(0),
-            Yielded: yielded,
-            Elements: $el.length
-          });
+        it('has the $el', () => {
+          cy.get('#list')[name](arg).then(function ($el) {
+            const { lastLog } = this
 
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq(obj);
-        }));
+            expect(lastLog.get('$el').get(0)).to.eq($el.get(0))
+          })
+        })
 
-        return it("can be turned off", () => cy.get("#list")[name](arg, {log: false}).then(function() {
-          const {
-            lastLog
-          } = this;
+        it('has a custom message', () => {
+          cy.get('#list')[name](arg).then(function () {
+            let message
 
-          return expect(lastLog.get("name")).to.eq("get");
-        }));
-      });
-    });
-  });
+            if (_.isUndefined(arg) || _.isFunction(arg)) {
+              message = ''
+            } else {
+              message = arg.toString()
+            }
 
-  it("eventually resolves", function() {
-    cy.on("command:retry", _.after(2, () => cy.$$("button:first").text("foo").addClass("bar"))
-    );
+            const { lastLog } = this
 
-    return cy.root().find("button:first").should("have.text", "foo").and("have.class", "bar");
-  });
+            expect(lastLog.get('message')).to.eq(message)
+          })
+        })
 
-  it("retries until it finds", function() {
-    const li = cy.$$("#list li:last");
-    const span = $("<span>foo</span>");
+        it('#consoleProps', () => {
+          cy.get('#list')[name](arg).then(function ($el) {
+            const obj = { Command: name }
 
-    const retry = _.after(3, () => li.append(span));
+            if (_.isFunction(arg)) {
+              obj.Selector = ''
+            } else {
+              obj.Selector = [].concat(arg).join(', ')
+            }
 
-    cy.on("command:retry", retry);
+            const yielded = Cypress.dom.getElements($el)
 
-    return cy.get("#list li:last").find("span").then($span => expect($span.get(0)).to.eq(span.get(0)));
-  });
+            _.extend(obj, {
+              'Applied To': helpers.getFirstSubjectByName('get').get(0),
+              Yielded: yielded,
+              Elements: $el.length,
+            })
 
-  it("retries until length equals n", function() {
-    let buttons = cy.$$("button");
+            expect(this.lastLog.invoke('consoleProps')).to.deep.eq(obj)
+          })
+        })
 
-    const length = buttons.length - 2;
+        it('can be turned off', () => {
+          cy.get('#list')[name](arg, { log: false }).then(function () {
+            const { lastLog } = this
 
-    cy.on("command:retry", _.after(2, () => {
-      buttons.last().remove();
-      return buttons = cy.$$("button");
+            expect(lastLog.get('name')).to.eq('get')
+          })
+        })
+      })
     })
-    );
+  })
 
-    //# should resolving after removing 2 buttons
-    return cy.root().find("button").should("have.length", length).then($buttons => expect($buttons.length).to.eq(length));
-  });
+  it('eventually resolves', () => {
+    cy.on('command:retry', _.after(2, () => {
+      cy.$$('button:first').text('foo').addClass('bar')
+    }))
 
-  it("should('not.exist')", function() {
-    cy.on("command:retry", _.after(3, () => {
-      return cy.$$("#nested-div").find("span").remove();
+    cy.root().find('button:first').should('have.text', 'foo').and('have.class', 'bar')
+  })
+
+  it('retries until it finds', () => {
+    const li = cy.$$('#list li:last')
+    const span = $('<span>foo</span>')
+
+    const retry = _.after(3, () => {
+      li.append(span)
     })
-    );
 
-    return cy.get("#nested-div").find("span").should("not.exist");
-  });
+    cy.on('command:retry', retry)
 
-  it("should('exist')", function() {
-    cy.on("command:retry", _.after(3, () => {
-      return cy.$$("#nested-div").append($("<strong />"));
+    cy.get('#list li:last').find('span').then(($span) => {
+      expect($span.get(0)).to.eq(span.get(0))
     })
-    );
+  })
+
+  it('retries until length equals n', () => {
+    let buttons = cy.$$('button')
 
-    return cy.get("#nested-div").find("strong");
-  });
+    const length = buttons.length - 2
 
-  //# https://github.com/cypress-io/cypress/issues/38
-  it("works with checkboxes", function() {
-    cy.on("command:retry", _.after(2, () => {
-      const c = cy.$$("[name=colors]").slice(0, 2);
-      return c.prop("checked", true);
+    cy.on('command:retry', _.after(2, () => {
+      buttons.last().remove()
+      buttons = cy.$$('button')
+    }))
+
+    // should resolving after removing 2 buttons
+    cy.root().find('button').should('have.length', length).then(($buttons) => {
+      expect($buttons.length).to.eq(length)
     })
-    );
+  })
+
+  it('should(\'not.exist\')', () => {
+    cy.on('command:retry', _.after(3, () => {
+      cy.$$('#nested-div').find('span').remove()
+    }))
+
+    cy.get('#nested-div').find('span').should('not.exist')
+  })
+
+  it('should(\'exist\')', () => {
+    cy.on('command:retry', _.after(3, () => {
+      cy.$$('#nested-div').append($('<strong />'))
+    }))
+
+    cy.get('#nested-div').find('strong')
+  })
+
+  // https://github.com/cypress-io/cypress/issues/38
+  it('works with checkboxes', () => {
+    cy.on('command:retry', _.after(2, () => {
+      const c = cy.$$('[name=colors]').slice(0, 2)
+
+      c.prop('checked', true)
+    }))
 
-    return cy.get("#by-name").find(":checked").should("have.length", 2);
-  });
+    cy.get('#by-name').find(':checked').should('have.length', 2)
+  })
 
-  it("does not log using first w/options", function() {
-    const logs = [];
+  it('does not log using first w/options', () => {
+    const logs = []
 
-    cy.on("log:added", function(attrs, log) {
-      if (attrs.name !== "assert") {
-        return logs.push(log);
+    cy.on('log:added', (attrs, log) => {
+      if (attrs.name !== 'assert') {
+        logs.push(log)
       }
-    });
+    })
+
+    cy.get('button').first({ log: false }).then(($button) => {
+      expect($button.length).to.eq(1)
+      expect(logs.length).to.eq(1)
+    })
+  })
+
+  describe('errors', () => {
+    beforeEach(function () {
+      Cypress.config('defaultCommandTimeout', 100)
+
+      this.logs = []
 
-    return cy.get("button").first({log: false}).then(function($button) {
-      expect($button.length).to.eq(1);
-      return expect(logs.length).to.eq(1);
-    });
-  });
+      cy.on('log:added', (attrs, log) => {
+        this.logs.push(log)
+      })
 
-  return describe("errors", function() {
-    beforeEach(function() {
-      Cypress.config("defaultCommandTimeout", 100);
+      return null
+    })
 
-      this.logs = [];
+    it('errors after timing out not finding element', (done) => {
+      cy.on('fail', (err) => {
+        expect(err.message).to.include('Expected to find element: `span`, but never found it. Queried from element: <li.item>')
 
-      cy.on("log:added", (attrs, log) => {
-        return this.logs.push(log);
-      });
+        done()
+      })
 
-      return null;
-    });
+      cy.get('#list li:last').find('span')
+    })
 
-    it("errors after timing out not finding element", function(done) {
-      cy.on("fail", function(err) {
-        expect(err.message).to.include("Expected to find element: `span`, but never found it. Queried from element: <li.item>");
-        return done();
-      });
+    it('throws once when incorrect sizzle selector', function (done) {
+      cy.on('fail', (err) => {
+        expect(this.logs.length).to.eq(2)
 
-      return cy.get("#list li:last").find("span");
-    });
+        done()
+      })
 
-    it("throws once when incorrect sizzle selector", function(done) {
-      cy.on("fail", err => {
-        expect(this.logs.length).to.eq(2);
-        return done();
-      });
+      cy.get('div:first').find('.spinner\'')
+    })
 
-      return cy.get("div:first").find(".spinner'");
-    });
+    it('logs out $el when existing $el is found even on failure', function (done) {
+      const button = cy.$$('#button').hide()
 
-    return it("logs out $el when existing $el is found even on failure", function(done) {
-      const button = cy.$$("#button").hide();
+      cy.on('fail', (err) => {
+        const log = this.logs[1]
 
-      cy.on("fail", err => {
-        const log = this.logs[1];
+        expect(log.get('state')).to.eq('failed')
+        expect(err.message).to.include(log.get('error').message)
+        expect(log.get('$el').get(0)).to.eq(button.get(0))
 
-        expect(log.get("state")).to.eq("failed");
-        expect(err.message).to.include(log.get("error").message);
-        expect(log.get("$el").get(0)).to.eq(button.get(0));
+        const consoleProps = log.invoke('consoleProps')
 
-        const consoleProps = log.invoke("consoleProps");
-        expect(consoleProps.Yielded).to.eq(button.get(0));
-        expect(consoleProps.Elements).to.eq(button.length);
-        return done();
-      });
+        expect(consoleProps.Yielded).to.eq(button.get(0))
+        expect(consoleProps.Elements).to.eq(button.length)
 
-      return cy.get("#dom").find("#button").should("be.visible");
-    });
-  });
-});
+        done()
+      })
+
+      cy.get('#dom').find('#button').should('be.visible')
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/waiting_spec.js b/packages/driver/test/cypress/integration/commands/waiting_spec.js
index 728ed69bdd97..b9b3a99d7001 100644
--- a/packages/driver/test/cypress/integration/commands/waiting_spec.js
+++ b/packages/driver/test/cypress/integration/commands/waiting_spec.js
@@ -1,1014 +1,1122 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const {
-  _
-} = Cypress;
-const {
-  Promise
-} = Cypress;
-
-const xhrGet = function(win, url) {
-  const xhr = new win.XMLHttpRequest;
-  xhr.open("GET", url);
-  return xhr.send();
-};
-
-describe("src/cy/commands/waiting", () => context("#wait", function() {
-  describe("number argument", function() {
-    it("passes delay onto Promise", function() {
-      const delay = cy.spy(Promise, "delay");
-
-      return cy.wait(50).then(() => expect(delay).to.be.calledWith(50, "wait"));
-    });
-
-    it("does not change the subject", () => cy
-      .wrap({})
-      .then(function(subject) {
-        return this.subject = subject;}).wait(10).then(function(subject) {
-        return expect(subject).to.eq(this.subject);
-    }));
-
-    return it("increases timeout by delta", function() {
-      const timeout = cy.spy(cy, "timeout");
-
-      return cy
-      .wait(50)
-      .then(() => expect(timeout).to.be.calledWith(50, true, "wait"));
-    });
-  });
-
-  describe("function argument", () => describe("errors thrown", () => it("is deprecated", function(done) {
-    cy.on("fail", err => {
-      expect(err.message).to.eq("`cy.wait(fn)` has been deprecated. Change this command to be `cy.should(fn)`.");
-      return done();
-    });
-
-    return cy.get("body").wait($body => expect($body).to.match("body"));
-  })));
-
-  describe("alias argument", function() {
-    before(() => cy.visit("/fixtures/jquery.html"));
-
-    it("waits for a route alias to have a response", function() {
-      const response = {foo: "foo"};
-
-      return cy
+const { _, Promise } = Cypress
+
+const xhrGet = function (win, url) {
+  const xhr = new win.XMLHttpRequest
+
+  xhr.open('GET', url)
+
+  return xhr.send()
+}
+
+describe('src/cy/commands/waiting', () => {
+  context('#wait', () => {
+    describe('number argument', () => {
+      it('passes delay onto Promise', () => {
+        const delay = cy.spy(Promise, 'delay')
+
+        cy.wait(50).then(() => {
+          expect(delay).to.be.calledWith(50, 'wait')
+        })
+      })
+
+      it('does not change the subject', () => {
+        cy
+        .wrap({})
+        .then(function (subject) {
+          this.subject = subject
+        })
+        .wait(10).then(function (subject) {
+          expect(subject).to.eq(this.subject)
+        })
+      })
+
+      it('increases timeout by delta', () => {
+        const timeout = cy.spy(cy, 'timeout')
+
+        cy
+        .wait(50)
+        .then(() => {
+          expect(timeout).to.be.calledWith(50, true, 'wait')
+        })
+      })
+    })
+
+    describe('function argument', () => {
+      describe('errors thrown', () => {
+        it('is deprecated', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('`cy.wait(fn)` has been deprecated. Change this command to be `cy.should(fn)`.')
+
+            done()
+          })
+
+          cy.get('body').wait(($body) => {
+            expect($body).to.match('body')
+          })
+        })
+      })
+    })
+
+    describe('alias argument', () => {
+      before(() => {
+        cy.visit('/fixtures/jquery.html')
+      })
+
+      it('waits for a route alias to have a response', () => {
+        const response = { foo: 'foo' }
+
+        cy
         .server()
-        .route("GET", /.*/, response).as("fetch")
-        .window().then(function(win) {
-          win.$.get("/foo");
-          return null;}).wait("@fetch").then(xhr => expect(xhr.responseBody).to.deep.eq(response));
-    });
-
-    it("waits for the route alias to have a request", function() {
-      cy.on("command:retry", _.once(() => {
-        const win = cy.state("window");
-        win.$.get("/users");
-        return null;
+        .route('GET', /.*/, response).as('fetch')
+        .window().then((win) => {
+          win.$.get('/foo')
+
+          return null
+        })
+        .wait('@fetch').then((xhr) => {
+          expect(xhr.responseBody).to.deep.eq(response)
+        })
       })
-      );
-
-      return cy
-        .server({delay: 1000})
-        .route(/users/, {}).as("getUsers")
-        .wait("@getUsers.request").then(function(xhr) {
-          expect(xhr.url).to.include("/users");
-          return expect(xhr.response).to.be.null;
-      });
-    });
-
-    it("passes timeout option down to requestTimeout of wait", function(done) {
-      const retry = _.after(3, _.once(() => {
-        return cy.state("window").$.get("/foo");
+
+      it('waits for the route alias to have a request', () => {
+        cy.on('command:retry', _.once(() => {
+          const win = cy.state('window')
+
+          win.$.get('/users')
+
+          return null
+        }))
+
+        cy
+        .server({ delay: 1000 })
+        .route(/users/, {}).as('getUsers')
+        .wait('@getUsers.request').then((xhr) => {
+          expect(xhr.url).to.include('/users')
+          expect(xhr.response).to.be.null
+        })
       })
-      );
 
-      cy.on("command:retry", function(options) {
-        expect(options.timeout).to.eq(900);
-        return done();
-      });
+      it('passes timeout option down to requestTimeout of wait', (done) => {
+        cy.on('command:retry', (options) => {
+          expect(options.timeout).to.eq(900)
 
-      return cy
+          done()
+        })
+
+        cy
         .server()
-        .route("GET", /.*/, {}).as("fetch")
-        .wait("@fetch", {timeout: 900});
-    });
+        .route('GET', /.*/, {}).as('fetch')
+        .wait('@fetch', { timeout: 900 })
+      })
+
+      it('resets the timeout after waiting', () => {
+        const prevTimeout = cy.timeout()
+
+        const retry = _.after(3, _.once(() => {
+          cy.state('window').$.get('/foo')
+        }))
 
-    it("resets the timeout after waiting", function() {
-      const prevTimeout = cy.timeout();
+        cy.on('command:retry', retry)
 
-      const retry = _.after(3, _.once(() => {
-        return cy.state("window").$.get("/foo");
+        cy
+        .server()
+        .route('GET', /.*/, {}).as('fetch')
+        .wait('@fetch').then(() => {
+          expect(cy.timeout()).to.eq(prevTimeout)
+        })
       })
-      );
 
-      cy.on("command:retry", retry);
+      it('waits for requestTimeout', (done) => {
+        Cypress.config('requestTimeout', 199)
+
+        cy.on('command:retry', (options) => {
+          expect(options.timeout).to.eq(199)
+
+          done()
+        })
 
-      return cy
+        cy
         .server()
-        .route("GET", /.*/, {}).as("fetch")
-        .wait("@fetch").then(() => expect(cy.timeout()).to.eq(prevTimeout));
-    });
+        .route('GET', '*', {}).as('fetch')
+        .wait('@fetch').then(() => {
+          expect(cy.timeout()).to.eq(199)
+        })
+      })
 
-    it("waits for requestTimeout", function(done) {
-      Cypress.config("requestTimeout", 199);
+      it('waits for requestTimeout override', (done) => {
+        cy.on('command:retry', (options) => {
+          expect(options.type).to.eq('request')
+          expect(options.timeout).to.eq(199)
 
-      cy.on("command:retry", function(options) {
-        expect(options.timeout).to.eq(199);
-        return done();
-      });
+          done()
+        })
 
-      return cy
+        cy
         .server()
-        .route("GET", "*", {}).as("fetch")
-        .wait("@fetch").then(() => expect(cy.timeout()).to.eq(199));
-    });
-
-    it("waits for requestTimeout override", function(done) {
-      cy.on("command:retry", function(options) {
-        expect(options.type).to.eq("request");
-        expect(options.timeout).to.eq(199);
-        return done();
-      });
-
-      return cy
+        .route('GET', '*', {}).as('fetch')
+        .wait('@fetch', { requestTimeout: 199 })
+      })
+
+      it('waits for responseTimeout', (done) => {
+        Cypress.config('responseTimeout', 299)
+
+        cy.on('command:retry', (options) => {
+          expect(options.timeout).to.eq(299)
+
+          done()
+        })
+
+        cy
+        .server({ delay: 100 })
+        .route('GET', '*', {}).as('fetch')
+        .window().then((win) => {
+          win.$.get('/foo')
+
+          return null
+        })
+        .wait('@fetch')
+      })
+
+      it('waits for responseTimeout override', (done) => {
+        cy.on('command:retry', (options) => {
+          expect(options.type).to.eq('response')
+          expect(options.timeout).to.eq(299)
+
+          done()
+        })
+
+        cy
+        .server({ delay: 100 })
+        .route('GET', '*', {}).as('fetch')
+        .window().then((win) => {
+          win.$.get('/foo')
+
+          return null
+        })
+        .wait('@fetch', { responseTimeout: 299 })
+      })
+
+      it('waits for requestTimeout and responseTimeout override', (done) => {
+        let retryCount = 0
+
+        cy.on('command:retry', (options) => {
+          retryCount++
+          if (retryCount === 1) {
+            expect(options.type).to.eq('request')
+            expect(options.timeout).to.eq(100)
+
+            // trigger request to move onto response timeout verification
+            const win = cy.state('window')
+
+            win.$.get('/foo')
+          }
+
+          if (retryCount === 2) {
+            expect(options.type).to.eq('response')
+            expect(options.timeout).to.eq(299)
+
+            done()
+          }
+        })
+
+        cy
+        .server({ delay: 100 })
+        .route('GET', '*', {}).as('fetch')
+        .wait('@fetch', { requestTimeout: 100, responseTimeout: 299 })
+      })
+
+      // https://github.com/cypress-io/cypress/issues/369
+      it('does not mutate 2nd route methods when using shorthand route', () => {
+        cy
         .server()
-        .route("GET", "*", {}).as("fetch")
-        .wait("@fetch", {requestTimeout: 199});
-    });
-
-    it("waits for responseTimeout", function(done) {
-      Cypress.config("responseTimeout", 299);
-
-      cy.on("command:retry", function(options) {
-        expect(options.timeout).to.eq(299);
-        return done();
-      });
-
-      return cy
-        .server({delay: 100})
-        .route("GET", "*", {}).as("fetch")
-        .window().then(function(win) {
-          win.$.get("/foo");
-          return null;}).wait("@fetch");
-    });
-
-    it("waits for responseTimeout override", function(done) {
-      cy.on("command:retry", function(options) {
-        expect(options.type).to.eq("response");
-        expect(options.timeout).to.eq(299);
-        return done();
-      });
-
-      return cy
-        .server({delay: 100})
-        .route("GET", "*", {}).as("fetch")
-        .window().then(function(win) {
-          win.$.get("/foo");
-          return null;}).wait("@fetch", {responseTimeout: 299});
-    });
-
-    it("waits for requestTimeout and responseTimeout override", function(done) {
-      let retryCount = 0;
-      cy.on("command:retry", function(options) {
-        retryCount++;
-        if (retryCount === 1) {
-          expect(options.type).to.eq("request");
-          expect(options.timeout).to.eq(100);
-
-          //# trigger request to move onto response timeout verification
-          const win = cy.state("window");
-          return win.$.get("/foo");
-        } else if (retryCount === 2) {
-          expect(options.type).to.eq("response");
-          expect(options.timeout).to.eq(299);
-          return done();
-        }
-      });
-
-      return cy
-        .server({delay: 100})
-        .route("GET", "*", {}).as("fetch")
-        .wait("@fetch", {requestTimeout: 100, responseTimeout: 299});
-    });
-
-    //# https://github.com/cypress-io/cypress/issues/369
-    it("does not mutate 2nd route methods when using shorthand route", () => cy
-      .server()
-      .route("POST", /foo/, {}).as("getFoo")
-      .route(/bar/, {}).as("getBar")
-      .window().then(function(win) {
-        win.$.post("/foo");
-        win.$.get("/bar");
-        return null;}).wait("@getBar"));
-
-    return describe("errors", function() {
-      beforeEach(() => Cypress.config("defaultCommandTimeout", 50));
-
-      it("throws when alias doesnt match a route", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` only accepts aliases for routes.\nThe alias: `b` did not match a route.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/wait");
-          return done();
-        });
-
-        return cy.get("body").as("b").wait("@b");
-      });
-
-      it("throws when route is never resolved", function(done) {
-        Cypress.config("requestTimeout", 100);
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `fetch`. No request ever occurred.");
-          return done();
-        });
-
-        cy.server();
-        cy.route("GET", /.*/, {}).as("fetch");
-        return cy.wait("@fetch");
-      });
-
-      it("throws when alias is never requested", function(done) {
-        Cypress.config("requestTimeout", 100);
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `foo`. No request ever occurred.");
-          return done();
-        });
-
-        return cy
-          .server()
-          .route(/foo/, {}).as("foo")
-          .wait("@foo.request");
-      });
+        .route('POST', /foo/, {}).as('getFoo')
+        .route(/bar/, {}).as('getBar')
+        .window().then((win) => {
+          win.$.post('/foo')
+          win.$.get('/bar')
 
-      it("throws when alias is missing '@' but matches an available alias", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("Invalid alias: `getAny`.\nYou forgot the `@`. It should be written as: `@getAny`.");
-          return done();
-        });
+          return null
+        })
+        .wait('@getBar')
+      })
 
-        return cy
-          .server()
-          .route("*", {}).as("getAny")
-          .wait("getAny").then(function() {});
-      });
+      describe('errors', () => {
+        beforeEach(() => {
+          Cypress.config('defaultCommandTimeout', 50)
+        })
 
-      it("throws when 2nd alias doesnt match any registered alias", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.wait()` could not find a registered alias for: `@bar`.\nAvailable aliases are: `foo`.");
-          return done();
-        });
+        it('throws when alias doesnt match a route', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` only accepts aliases for routes.\nThe alias: `b` did not match a route.')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/wait')
 
-        return cy
-          .server()
-          .route(/foo/, {}).as("foo")
-          .window().then(function(win) {
-            win.$.get("/foo");
-            return null;}).wait(["@foo", "@bar"]);
-      });
-
-      it("throws when 2nd alias is missing '@' but matches an available alias", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("Invalid alias: `bar`.\nYou forgot the `@`. It should be written as: `@bar`.");
-          return done();
-        });
-
-        return cy
+            done()
+          })
+
+          cy.get('body').as('b').wait('@b')
+        })
+
+        it('throws when route is never resolved', (done) => {
+          Cypress.config('requestTimeout', 100)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `fetch`. No request ever occurred.')
+
+            done()
+          })
+
+          cy.server()
+          cy.route('GET', /.*/, {}).as('fetch')
+          cy.wait('@fetch')
+        })
+
+        it('throws when alias is never requested', (done) => {
+          Cypress.config('requestTimeout', 100)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `foo`. No request ever occurred.')
+
+            done()
+          })
+
+          cy
           .server()
-          .route(/foo/, {}).as("foo")
-          .route(/bar/, {}).as("bar")
-          .window().then(function(win) {
-            win.$.get("/foo");
-            return null;}).wait(["@foo", "bar"]);
-      });
-
-      it("throws when 2nd alias isnt a route alias", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` only accepts aliases for routes.\nThe alias: `bar` did not match a route.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/wait");
-          return done();
-        });
-
-        return cy
+          .route(/foo/, {}).as('foo')
+          .wait('@foo.request')
+        })
+
+        it('throws when alias is missing \'@\' but matches an available alias', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('Invalid alias: `getAny`.\nYou forgot the `@`. It should be written as: `@getAny`.')
+
+            done()
+          })
+
+          cy
           .server()
-          .route(/foo/, {}).as("foo")
-          .get("body").as("bar")
-          .window().then(function(win) {
-            win.$.get("/foo");
-            return null;}).wait(["@foo", "@bar"]);
-      });
-
-      it("throws whenever an alias times out", function(done) {
-        Cypress.config("requestTimeout", 1000);
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `1000ms` for the 1st request to the route: `foo`. No request ever occurred.");
-          return done();
-        });
-
-        cy.on("command:retry", function(options) {
-          //# force foo to time out before bar
-          if (/foo/.test(options.error)) {
-            return options._runnableTimeout = 0;
-          }
-        });
+          .route('*', {}).as('getAny')
+          .wait('getAny').then(() => {})
+        })
 
-        return cy
+        it('throws when 2nd alias doesnt match any registered alias', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('`cy.wait()` could not find a registered alias for: `@bar`.\nAvailable aliases are: `foo`.')
+
+            done()
+          })
+
+          cy
           .server()
-          .route(/foo/, {}).as("foo")
-          .route(/bar/, {}).as("bar")
-          .wait(["@foo", "@bar"]);
-      });
+          .route(/foo/, {}).as('foo')
+          .window().then((win) => {
+            win.$.get('/foo')
+
+            return null
+          })
+          .wait(['@foo', '@bar'])
+        })
 
-      it("throws when bar cannot resolve", function(done) {
-        Cypress.config("requestTimeout", 100);
+        it('throws when 2nd alias is missing \'@\' but matches an available alias', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('Invalid alias: `bar`.\nYou forgot the `@`. It should be written as: `@bar`.')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `bar`. No request ever occurred.");
-          return done();
-        });
+            done()
+          })
 
-        cy.on("command:retry", _.once(() => {
-          const win = cy.state("window");
-          win.$.get("/foo");
-          return null;
+          cy
+          .server()
+          .route(/foo/, {}).as('foo')
+          .route(/bar/, {}).as('bar')
+          .window().then((win) => {
+            win.$.get('/foo')
+
+            return null
+          })
+          .wait(['@foo', 'bar'])
         })
-        );
 
-        return cy
+        it('throws when 2nd alias isnt a route alias', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` only accepts aliases for routes.\nThe alias: `bar` did not match a route.')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/wait')
+
+            done()
+          })
+
+          cy
           .server()
-          .route(/foo/, {foo: "foo"}).as("foo")
-          .route(/bar/, {bar: "bar"}).as("bar")
-          .wait(["@foo", "@bar"]);
-      });
+          .route(/foo/, {}).as('foo')
+          .get('body').as('bar')
+          .window().then((win) => {
+            win.$.get('/foo')
+
+            return null
+          })
+          .wait(['@foo', '@bar'])
+        })
+
+        it('throws whenever an alias times out', (done) => {
+          Cypress.config('requestTimeout', 1000)
 
-      it("throws when foo cannot resolve", function(done) {
-        Cypress.config("requestTimeout", 100);
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `1000ms` for the 1st request to the route: `foo`. No request ever occurred.')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `foo`. No request ever occurred.");
-          return done();
-        });
+            done()
+          })
 
-        cy.on("command:retry", _.once(() => {
-          const win = cy.state("window");
-          win.$.get("/bar");
-          return null;
+          cy.on('command:retry', (options) => {
+            // force foo to time out before bar
+            if (/foo/.test(options.error)) {
+              options._runnableTimeout = 0
+            }
+          })
+
+          cy
+          .server()
+          .route(/foo/, {}).as('foo')
+          .route(/bar/, {}).as('bar')
+          .wait(['@foo', '@bar'])
         })
-        );
 
-        return cy
+        it('throws when bar cannot resolve', (done) => {
+          Cypress.config('requestTimeout', 100)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `bar`. No request ever occurred.')
+
+            done()
+          })
+
+          cy.on('command:retry', _.once(() => {
+            const win = cy.state('window')
+
+            win.$.get('/foo')
+
+            return null
+          }))
+
+          cy
           .server()
-          .route(/foo/, {foo: "foo"}).as("foo")
-          .route(/bar/, {bar: "bar"}).as("bar")
-          .wait(["@foo", "@bar"]);
-      });
+          .route(/foo/, { foo: 'foo' }).as('foo')
+          .route(/bar/, { bar: 'bar' }).as('bar')
+          .wait(['@foo', '@bar'])
+        })
+
+        it('throws when foo cannot resolve', (done) => {
+          Cypress.config('requestTimeout', 100)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `foo`. No request ever occurred.')
+
+            done()
+          })
 
-      it("does not throw another timeout error when 2nd alias is missing @", function(done) {
-        Promise.onPossiblyUnhandledRejection(done);
+          cy.on('command:retry', _.once(() => {
+            const win = cy.state('window')
 
-        Cypress.config("requestTimeout", 100);
+            win.$.get('/bar')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("Invalid alias: `bar`.\nYou forgot the `@`. It should be written as: `@bar`.");
-          return done();
-        });
+            return null
+          }))
 
-        return cy
+          cy
           .server()
-          .route(/foo/, {}).as("foo")
-          .route(/bar/, {}).as("bar")
-          .wait(["@foo", "bar"]);
-      });
+          .route(/foo/, { foo: 'foo' }).as('foo')
+          .route(/bar/, { bar: 'bar' }).as('bar')
+          .wait(['@foo', '@bar'])
+        })
+
+        it('does not throw another timeout error when 2nd alias is missing @', (done) => {
+          Promise.onPossiblyUnhandledRejection(done)
 
-      it("does not throw again when 2nd alias doesnt reference a route", function(done) {
-        Promise.onPossiblyUnhandledRejection(done);
+          Cypress.config('requestTimeout', 100)
 
-        Cypress.config("requestTimeout", 100);
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('Invalid alias: `bar`.\nYou forgot the `@`. It should be written as: `@bar`.')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.wait()` only accepts aliases for routes.\nThe alias: `bar` did not match a route.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/wait");
-          return done();
-        });
+            done()
+          })
 
-        return cy
+          cy
           .server()
-          .route(/foo/, {}).as("foo")
-          .get("body").as("bar")
-          .wait(["@foo", "@bar"]);
-      });
+          .route(/foo/, {}).as('foo')
+          .route(/bar/, {}).as('bar')
+          .wait(['@foo', 'bar'])
+        })
 
-      it("does not retry after 1 alias times out", function(done) {
-        Promise.onPossiblyUnhandledRejection(done);
+        it('does not throw again when 2nd alias doesnt reference a route', (done) => {
+          Promise.onPossiblyUnhandledRejection(done)
 
-        Cypress.config("requestTimeout", 1000);
+          Cypress.config('requestTimeout', 100)
 
-        cy.on("command:retry", function(options) {
-          //# force bar to time out before foo
-          if (/bar/.test(options.error)) {
-            return options._runnableTimeout = 0;
-          }
-        });
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('`cy.wait()` only accepts aliases for routes.\nThe alias: `bar` did not match a route.')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/wait')
 
-        cy.on("fail", err => {
-          return done();
-        });
+            done()
+          })
 
-        return cy
+          cy
           .server()
-          .route(/foo/, {foo: "foo"}).as("foo")
-          .route(/bar/, {bar: "bar"}).as("bar")
-          .wait(["@foo", "@bar"]);
-      });
+          .route(/foo/, {}).as('foo')
+          .get('body').as('bar')
+          .wait(['@foo', '@bar'])
+        })
+
+        it('does not retry after 1 alias times out', (done) => {
+          Promise.onPossiblyUnhandledRejection(done)
+
+          Cypress.config('requestTimeout', 1000)
+
+          cy.on('command:retry', (options) => {
+            // force bar to time out before foo
+            if (/bar/.test(options.error)) {
+              options._runnableTimeout = 0
+            }
+          })
 
-      it("throws waiting for the 3rd response", function(done) {
-        const resp = {foo: "foo"};
-        let response = 0;
+          cy.on('fail', (err) => {
+            done()
+          })
 
-        Cypress.config("requestTimeout", 200);
+          cy
+          .server()
+          .route(/foo/, { foo: 'foo' }).as('foo')
+          .route(/bar/, { bar: 'bar' }).as('bar')
+          .wait(['@foo', '@bar'])
+        })
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `200ms` for the 3rd request to the route: `get.users`. No request ever occurred.");
-          return done();
-        });
+        it('throws waiting for the 3rd response', (done) => {
+          const resp = { foo: 'foo' }
+          let response = 0
 
-        cy.on("command:retry", () => {
-          response += 1;
+          Cypress.config('requestTimeout', 200)
 
-          //# dont send the 3rd response
-          if (response === 3) { return cy.removeAllListeners("command:retry"); }
-          const win = cy.state("window");
-          return win.$.get("/users", {num: response});
-        });
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `200ms` for the 3rd request to the route: `get.users`. No request ever occurred.')
 
-        cy.server();
-        cy.route(/users/, resp).as("get.users");
-        return cy.wait(["@get.users", "@get.users", "@get.users"]);
-      });
+            done()
+          })
 
-      it("throws waiting for the 2nd response", function(done) {
-        const resp = {foo: "foo"};
-        let response = 0;
+          cy.on('command:retry', () => {
+            response += 1
 
-        Cypress.config("requestTimeout", 200);
+            // dont send the 3rd response
+            if (response === 3) {
+              return cy.removeAllListeners('command:retry')
+            }
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `200ms` for the 2nd request to the route: `getUsers`. No request ever occurred.");
-          return done();
-        });
+            const win = cy.state('window')
 
-        //# dont send the 2nd response
-        cy.on("command:retry", _.once(() => {
-          response += 1;
-          const win = cy.state("window");
-          return win.$.get("/users", {num: response});
+            win.$.get('/users', { num: response })
+          })
+
+          cy.server()
+          cy.route(/users/, resp).as('get.users')
+          cy.wait(['@get.users', '@get.users', '@get.users'])
         })
-        );
 
-        return cy
-          .server()
-          .route(/users/, resp).as("getUsers")
-          .wait("@getUsers")
-          .wait("@getUsers");
-      });
+        it('throws waiting for the 2nd response', (done) => {
+          const resp = { foo: 'foo' }
+          let response = 0
 
-      it("throws waiting for the 2nd request", function(done) {
-        const resp = {foo: "foo"};
-        let request = 0;
+          Cypress.config('requestTimeout', 200)
 
-        Cypress.config("requestTimeout", 200);
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `200ms` for the 2nd request to the route: `getUsers`. No request ever occurred.')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `200ms` for the 2nd request to the route: `getUsers`. No request ever occurred.");
-          return done();
-        });
+            done()
+          })
 
-        //# dont send the 2nd request
-        cy.on("command:retry", _.once(() => {
-          request += 1;
-          const win = cy.state("window");
-          return win.$.get("/users", {num: request});
+          // dont send the 2nd response
+          cy.on('command:retry', _.once(() => {
+            response += 1
+            const win = cy.state('window')
+
+            win.$.get('/users', { num: response })
+          }))
+
+          cy
+          .server()
+          .route(/users/, resp).as('getUsers')
+          .wait('@getUsers')
+          .wait('@getUsers')
         })
-        );
 
-        return cy
+        it('throws waiting for the 2nd request', (done) => {
+          const resp = { foo: 'foo' }
+          let request = 0
+
+          Cypress.config('requestTimeout', 200)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `200ms` for the 2nd request to the route: `getUsers`. No request ever occurred.')
+
+            done()
+          })
+
+          // dont send the 2nd request
+          cy.on('command:retry', _.once(() => {
+            request += 1
+            const win = cy.state('window')
+
+            win.$.get('/users', { num: request })
+          }))
+
+          cy
           .server()
-          .route(/users/, resp).as("getUsers")
-          .wait("@getUsers.request")
-          .wait("@getUsers.request");
-      });
+          .route(/users/, resp).as('getUsers')
+          .wait('@getUsers.request')
+          .wait('@getUsers.request')
+        })
+
+        it('throws when waiting for response to route', (done) => {
+          Cypress.config('responseTimeout', 100)
 
-      it("throws when waiting for response to route", function(done) {
-        Cypress.config("responseTimeout", 100);
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `100ms` for the 1st response to the route: `response`. No response ever occurred.')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `100ms` for the 1st response to the route: `response`. No response ever occurred.");
-          return done();
-        });
+            done()
+          })
 
-        return cy
+          cy
           .server()
-          .route("*").as("response")
-          .window().then(function(win) {
-            win.$.get("/timeout?ms=500");
-            return null;}).wait("@response");
-      });
+          .route('*').as('response')
+          .window().then((win) => {
+            win.$.get('/timeout?ms=500')
+
+            return null
+          })
+          .wait('@response')
+        })
 
-      it("throws when waiting for 2nd response to route", function(done) {
-        Cypress.config("responseTimeout", 200);
+        it('throws when waiting for 2nd response to route', (done) => {
+          Cypress.config('responseTimeout', 200)
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `200ms` for the 2nd response to the route: `response`. No response ever occurred.");
-          return done();
-        });
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `200ms` for the 2nd response to the route: `response`. No response ever occurred.')
 
-        return cy
+            done()
+          })
+
+          cy
           .server()
-          .route("*").as("response")
-          .window().then(function(win) {
-            win.$.get("/timeout?ms=0");
-            win.$.get("/timeout?ms=5000");
-            return null;}).wait(["@response", "@response"]);
-      });
-
-      it("throws when waiting for 1st response to bar", function(done) {
-        Cypress.config("responseTimeout", 200);
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `200ms` for the 1st response to the route: `bar`. No response ever occurred.");
-          return done();
-        });
-
-        return cy
+          .route('*').as('response')
+          .window().then((win) => {
+            win.$.get('/timeout?ms=0')
+            win.$.get('/timeout?ms=5000')
+
+            return null
+          })
+          .wait(['@response', '@response'])
+        })
+
+        it('throws when waiting for 1st response to bar', (done) => {
+          Cypress.config('responseTimeout', 200)
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `200ms` for the 1st response to the route: `bar`. No response ever occurred.')
+
+            done()
+          })
+
+          cy
           .server()
-          .route("/timeout?ms=0").as("foo")
-          .route("/timeout?ms=5000").as("bar")
-          .window().then(function(win) {
-            win.$.get("/timeout?ms=0");
-            win.$.get("/timeout?ms=5000");
-            return null;}).wait(["@foo", "@bar"]);
-      });
-
-      it("throws when waiting on the 2nd request", function(done) {
-        Cypress.config("requestTimeout", 200);
-
-        cy.on("command:retry", _.once(() => {
-          const win = cy.state("window");
-          win.$.get("/users");
-          return null;
-        })
-        );
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `200ms` for the 2nd request to the route: `getUsers`. No request ever occurred.");
-          return done();
-        });
-
-        return cy
-          .server({delay: 200})
-          .route(/users/, {}).as("getUsers")
-          .wait("@getUsers.request").then(function(xhr) {
-            expect(xhr.url).to.include("/users");
-            return expect(xhr.response).to.be.null;}).wait("@getUsers");
-      });
-
-      it("throws when waiting on the 3rd request on array of aliases", function(done) {
-        Cypress.config("requestTimeout", 500);
-        Cypress.config("responseTimeout", 10000);
-
-        cy.on("command:retry", _.once(() => {
-          const win = cy.state("window");
-          _.defer(() => win.$.get("/timeout?ms=2001"));
-          return _.defer(() => win.$.get("/timeout?ms=2002"));
-        })
-        );
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `500ms` for the 1st request to the route: `get.three`. No request ever occurred.");
-          return done();
-        });
-
-        cy.server();
-        cy.route("/timeout?ms=2001").as("getOne");
-        cy.route("/timeout?ms=2002").as("getTwo");
-        cy.route(/three/, {}).as("get.three");
-        return cy.wait(["@getOne", "@getTwo", "@get.three"]);
-      });
-
-      it("throws when waiting on the 3rd response on array of aliases", function(done) {
-        Cypress.config("requestTimeout", 200);
-        Cypress.config("responseTimeout", 1000);
-
-        const win = cy.state("window");
-
-        cy.on("command:retry", function(options) {
-          if (/getThree/.test(options.error)) {
-            //# force 3 to immediately time out
-            return options._runnableTimeout = 0;
-          }
-        });
+          .route('/timeout?ms=0').as('foo')
+          .route('/timeout?ms=5000').as('bar')
+          .window().then((win) => {
+            win.$.get('/timeout?ms=0')
+            win.$.get('/timeout?ms=5000')
+
+            return null
+          })
+          .wait(['@foo', '@bar'])
+        })
+
+        it('throws when waiting on the 2nd request', (done) => {
+          Cypress.config('requestTimeout', 200)
+
+          cy.on('command:retry', _.once(() => {
+            const win = cy.state('window')
+
+            win.$.get('/users')
+
+            return null
+          }))
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `200ms` for the 2nd request to the route: `getUsers`. No request ever occurred.')
+
+            done()
+          })
+
+          cy
+          .server({ delay: 200 })
+          .route(/users/, {}).as('getUsers')
+          .wait('@getUsers.request').then((xhr) => {
+            expect(xhr.url).to.include('/users')
+            expect(xhr.response).to.be.null
+          })
+          .wait('@getUsers')
+        })
+
+        it('throws when waiting on the 3rd request on array of aliases', (done) => {
+          Cypress.config('requestTimeout', 500)
+          Cypress.config('responseTimeout', 10000)
+
+          cy.on('command:retry', _.once(() => {
+            const win = cy.state('window')
 
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.wait()` timed out waiting `1000ms` for the 1st response to the route: `getThree`. No response ever occurred.");
-          return done();
-        });
+            _.defer(() => {
+              win.$.get('/timeout?ms=2001')
+            })
 
-        return cy
+            _.defer(() => {
+              win.$.get('/timeout?ms=2002')
+            })
+          }))
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `500ms` for the 1st request to the route: `get.three`. No request ever occurred.')
+
+            done()
+          })
+
+          cy.server()
+          cy.route('/timeout?ms=2001').as('getOne')
+          cy.route('/timeout?ms=2002').as('getTwo')
+          cy.route(/three/, {}).as('get.three')
+          cy.wait(['@getOne', '@getTwo', '@get.three'])
+        })
+
+        it('throws when waiting on the 3rd response on array of aliases', (done) => {
+          Cypress.config('requestTimeout', 200)
+          Cypress.config('responseTimeout', 1000)
+
+          const win = cy.state('window')
+
+          cy.on('command:retry', (options) => {
+            if (/getThree/.test(options.error)) {
+              options._runnableTimeout = 0
+            }
+          })
+
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.wait()` timed out waiting `1000ms` for the 1st response to the route: `getThree`. No response ever occurred.')
+
+            done()
+          })
+
+          cy
           .server()
-          .route("/timeout?ms=1").as("getOne")
-          .route("/timeout?ms=2").as("getTwo")
-          .route("/timeout?ms=3000").as("getThree")
-          .then(function() {
-            win.$.get("/timeout?ms=1");
-            win.$.get("/timeout?ms=2");
-            win.$.get("/timeout?ms=3000");
-
-            return null;}).wait(["@getOne", "@getTwo", "@getThree"]);
-      });
-
-      return it("throws when passed multiple string arguments", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.wait()` was passed invalid arguments. You cannot pass multiple strings. If you're trying to wait for multiple routes, use an array.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/wait");
-          return done();
-        });
-
-        return cy.wait("@foo", "@bar");
-      });
-    });
-  });
-
-  describe("multiple alias arguments", function() {
-    before(() => cy.visit("/fixtures/jquery.html"));
-
-    return it("can wait for all requests to have a response", function() {
-      const resp1 = {foo: "foo"};
-      const resp2 = {bar: "bar"};
-
-      cy.server();
-      cy.route(/users/, resp1).as("getUsers");
-      cy.route(/posts/, resp2).as("get.posts");
-      cy.window().then(function(win) {
-        win.$.get("/users");
-        win.$.get("/posts");
-        return null;
-      });
-      return cy.wait(["@getUsers", "@get.posts"]).spread(function(xhr1, xhr2) {
-        expect(xhr1.responseBody).to.deep.eq(resp1);
-        return expect(xhr2.responseBody).to.deep.eq(resp2);
-      });
-    });
-  });
-
-  describe("multiple separate alias waits", function() {
-    before(() => cy.visit("/fixtures/jquery.html"));
-
-    it("waits for a 3rd request before resolving", function() {
-      const resp = {foo: "foo"};
-      let response = 0;
-
-      const win = cy.state("window");
-
-      cy.on("command:retry", function(options) {
-        if (options._retries === 1) {
-          response += 1;
-          return win.$.get("/users", {num: response});
-        }
-      });
-
-      return cy
-        .server()
-        .route(/users/, resp).as("getUsers")
-        .wait("@getUsers").then(function(xhr) {
-          expect(xhr.url).to.include("/users?num=1");
-          return expect(xhr.responseBody).to.deep.eq(resp);}).wait("@getUsers").then(function(xhr) {
-          expect(xhr.url).to.include("/users?num=2");
-          return expect(xhr.responseBody).to.deep.eq(resp);}).wait("@getUsers").then(function(xhr) {
-          expect(xhr.url).to.include("/users?num=3");
-          return expect(xhr.responseBody).to.deep.eq(resp);
-      });
-    });
-
-    //# FIXME: failing in CI sometimes https://circleci.com/gh/cypress-io/cypress/5655
-    it.skip("waits for the 4th request before resolving", function() {
-      const resp = {foo: "foo"};
-      let response = 0;
-
-      const win = cy.state("window");
-
-      cy.on("command:retry", function(options) {
-        //# only add a request for the first unique retry
-        //# for each request
-        if (options._retries === 1) {
-          response += 1;
-          return win.$.get("/users", {num: response});
-        }
-      });
-
-      return cy
-        .server()
-        .route(/users/, resp).as("getUsers")
-        .wait(["@getUsers", "@getUsers", "@getUsers"]).spread(function(xhr1, xhr2, xhr3) {
-          expect(xhr1.url).to.include("/users?num=1");
-          expect(xhr2.url).to.include("/users?num=2");
-          return expect(xhr3.url).to.include("/users?num=3");}).wait("@getUsers").then(function(xhr) {
-          expect(xhr.url).to.include("/users?num=4");
-          return expect(xhr.responseBody).to.deep.eq(resp);
-      });
-    });
-    return null;
-  });
-
-  describe("errors", () => describe("invalid 1st argument", function() {
-    beforeEach(() => Cypress.config("defaultCommandTimeout", 50));
-
-    return _.each([
-        { type: 'NaN', val: 0/0, errVal: 'NaN' },
-        { type: 'Infinity', val: Infinity, errVal: 'Infinity' },
-        { type: 'Array', val: [] },
-        { type: 'null', val: null },
-        { type: 'undefined', val: undefined },
-        { type: 'Boolean', val: true },
-        { type: 'Object', val: {} },
-        { type: 'Symbol', val: Symbol.iterator, errVal: "Symbol(Symbol.iterator)" }
-      ], attrs => {
-      return it(`throws when 1st arg is ${attrs.type}`, done => {
-        cy.on("fail", err => {
-          expect(err.message).to.eq(`\`cy.wait()\` only accepts a number, an alias of a route, or an array of aliases of routes. You passed: \`${attrs.errVal || JSON.stringify(attrs.val)}\``);
-          expect(err.docsUrl).to.eq("https://on.cypress.io/wait");
-          return done();
-        });
-        return cy.get("body").wait(attrs.val);
-      });
-    });
-  }));
-
-  return describe(".log", function() {
-    beforeEach(function() {
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        this.lastLog = log;
-        return this.logs.push(log);
-      });
-
-      return null;
-    });
-
-    it("can turn off logging", () => cy.wait(10, {log: false}).then(function() {
-      const {
-        lastLog
-      } = this;
-
-      return expect(lastLog).to.be.undefined;
-    }));
-
-    describe("number argument", function() {
-      it("does not immediately end", function() {
-        cy.on("log:added", function(attrs, log) {
-          if (attrs.name === "wait") {
-            return expect(log.get("state")).not.to.eq("passed");
-          }
-        });
+          .route('/timeout?ms=1').as('getOne')
+          .route('/timeout?ms=2').as('getTwo')
+          .route('/timeout?ms=3000').as('getThree')
+          .then(() => {
+            win.$.get('/timeout?ms=1')
+            win.$.get('/timeout?ms=2')
+            win.$.get('/timeout?ms=3000')
+
+            return null
+          }).wait(['@getOne', '@getTwo', '@getThree'])
+        })
+
+        it('throws when passed multiple string arguments', (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.eq('`cy.wait()` was passed invalid arguments. You cannot pass multiple strings. If you\'re trying to wait for multiple routes, use an array.')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/wait')
+
+            done()
+          })
+
+          cy.wait('@foo', '@bar')
+        })
+      })
+    })
+
+    describe('multiple alias arguments', () => {
+      before(() => {
+        cy.visit('/fixtures/jquery.html')
+      })
+
+      it('can wait for all requests to have a response', () => {
+        const resp1 = { foo: 'foo' }
+        const resp2 = { bar: 'bar' }
+
+        cy.server()
+        cy.route(/users/, resp1).as('getUsers')
+        cy.route(/posts/, resp2).as('get.posts')
+        cy.window().then((win) => {
+          win.$.get('/users')
+          win.$.get('/posts')
+
+          return null
+        })
+
+        cy.wait(['@getUsers', '@get.posts']).spread((xhr1, xhr2) => {
+          expect(xhr1.responseBody).to.deep.eq(resp1)
+          expect(xhr2.responseBody).to.deep.eq(resp2)
+        })
+      })
+    })
+
+    describe('multiple separate alias waits', () => {
+      before(() => {
+        cy.visit('/fixtures/jquery.html')
+      })
+
+      it('waits for a 3rd request before resolving', () => {
+        const resp = { foo: 'foo' }
+        let response = 0
 
-        return cy.noop({}).wait(10).then(function() {
-          const {
-            lastLog
-          } = this;
+        const win = cy.state('window')
 
-          return expect(lastLog.get("state")).to.eq("passed");
-        });
-      });
+        cy.on('command:retry', (options) => {
+          if (options._retries === 1) {
+            response += 1
 
-      it("does not immediately snapshot", function() {
-        cy.on("log:added", function(attrs, log) {
-          if (attrs.name === "wait") {
-            return expect(log.get("snapshots")).not.to.be.ok;
+            return win.$.get('/users', { num: response })
           }
-        });
-
-        return cy.noop({}).wait(10).then(function() {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("snapshots").length).to.eq(1);
-          return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-        });
-      });
-
-      it("is a type: child if subject", () => cy.noop({}).wait(10).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("type")).to.eq("child");
-      }));
-
-      it("is a type: child if subject is false", function() {
-        cy.noop(false).wait(10).then(function() {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("type")).to.eq("child");
-
-          return it("is a type: parent if subject is null or undefined", function() {});
-        });
-        return cy.wait(10).then(function() {
-          const {
-            lastLog
-          } = this;
-
-          return expect(lastLog.get("type")).to.eq("parent");
-        });
-      });
-
-      it("#consoleProps", () => cy.wait(10).then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "wait",
-          "Waited For": "10ms before continuing",
-          "Yielded": undefined
-        });}));
-
-      return it("#consoleProps as a child", () => cy.wrap({}).wait(10).then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "wait",
-          "Waited For": "10ms before continuing",
-          "Yielded": {}
-        });}));
-  });
-
-    describe("alias argument errors", function() {
-      it(".log", function(done) {
-        Cypress.config("requestTimeout", 100);
-
-        let numRetries = 0;
-
-        cy.on("fail", err => {
-          const obj = {
-            name: "wait",
-            referencesAlias: [{name: 'getFoo', cardinal: 1, ordinal: "1st"}],
-            aliasType: "route",
-            type: "parent",
-            error: err,
-            instrument: "command",
-            message: "@getFoo"
-            // numRetries: numRetries + 1
-          };
-
-          const {
-            lastLog
-          } = this;
-
-          _.each(obj, (value, key) => {
-            return expect(lastLog.get(key)).deep.eq(value, `expected key: ${key} to eq value: ${value}`);
-          });
-
-          return done();
-        });
-
-        cy.on("command:retry", () => numRetries += 1);
-
-        cy.server();
-        cy.route(/foo/, {}).as("getFoo");
-        return cy.noop({}).wait("@getFoo");
-      });
-
-      it("only logs once", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.eq("`cy.wait()` could not find a registered alias for: `@foo`.\nYou have not aliased anything yet.");
-          return done();
-        });
-
-        return cy.wait("@foo");
-      });
-
-      return it("#consoleProps multiple aliases", function(done) {
-        Cypress.config("requestTimeout", 100);
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("error")).to.eq(err);
-          expect(err.message).to.include("`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `getBar`. No request ever occurred.");
-          return done();
-        });
-
-        return cy
-          .server()
-          .route(/foo/, {}).as("getFoo")
-          .route(/bar/, {}).as("getBar")
-          .window().then(function(win) {
-            xhrGet(win, "/foo");
-            return null;}).wait(["@getFoo", "@getBar"]);
-      });
-    });
-
-    describe("function argument errors", function() {
-      it(".log");
-
-      return it("#consoleProps");
-    });
-
-    return describe("alias argument", function() {
-      it("is a parent command", () => cy
+        })
+
+        cy
         .server()
-        .route(/foo/, {}).as("getFoo")
-        .window().then(function(win) {
-          xhrGet(win, "/foo");
-          return null;}).wait("@getFoo").then(function() {
-          const {
-            lastLog
-          } = this;
-
-          return expect(lastLog.get("type")).to.eq("parent");
-      }));
-
-      it("passes as array of referencesAlias", () => cy
+        .route(/users/, resp).as('getUsers')
+        .wait('@getUsers').then((xhr) => {
+          expect(xhr.url).to.include('/users?num=1')
+          expect(xhr.responseBody).to.deep.eq(resp)
+        })
+        .wait('@getUsers').then((xhr) => {
+          expect(xhr.url).to.include('/users?num=2')
+          expect(xhr.responseBody).to.deep.eq(resp)
+        })
+        .wait('@getUsers').then((xhr) => {
+          expect(xhr.url).to.include('/users?num=3')
+          expect(xhr.responseBody).to.deep.eq(resp)
+        })
+      })
+
+      // FIXME: failing in CI sometimes https://circleci.com/gh/cypress-io/cypress/5655
+      it.skip('waits for the 4th request before resolving', () => {
+        const resp = { foo: 'foo' }
+        let response = 0
+
+        const win = cy.state('window')
+
+        cy.on('command:retry', (options) => {
+          // only add a request for the first unique retry
+          // for each request
+          if (options._retries === 1) {
+            response += 1
+
+            win.$.get('/users', { num: response })
+          }
+        })
+
+        cy
         .server()
-        .route(/foo/, {}).as("getFoo")
-        .route(/bar/, {}).as("getBar")
-        .window().then(function(win) {
-          xhrGet(win, "/foo");
-          xhrGet(win, "/bar");
-          xhrGet(win, "/foo");
-          return null;}).wait(["@getFoo", "@getBar", "@getFoo"]).then(function(xhrs) {
-          const {
-            lastLog
-          } = this;
-
-          return expect(lastLog.get("referencesAlias")).to.deep.eq([
-            {
-              name: "getFoo",
-              cardinal: 1,
-              ordinal: '1st'
-            },
-            {
-              name: "getBar",
-              cardinal: 1,
-              ordinal: '1st'
-            },
-            {
-              name: "getFoo",
-              cardinal: 2,
-              ordinal: '2nd'
+        .route(/users/, resp).as('getUsers')
+        .wait(['@getUsers', '@getUsers', '@getUsers']).spread((xhr1, xhr2, xhr3) => {
+          expect(xhr1.url).to.include('/users?num=1')
+          expect(xhr2.url).to.include('/users?num=2')
+
+          expect(xhr3.url).to.include('/users?num=3')
+        }).wait('@getUsers').then((xhr) => {
+          expect(xhr.url).to.include('/users?num=4')
+
+          expect(xhr.responseBody).to.deep.eq(resp)
+        })
+      })
+
+      return null
+    })
+
+    describe('errors', () => {
+      describe('invalid 1st argument', () => {
+        beforeEach(() => {
+          Cypress.config('defaultCommandTimeout', 50)
+        })
+
+        _.each([
+          { type: 'NaN', val: 0 / 0, errVal: 'NaN' },
+          { type: 'Infinity', val: Infinity, errVal: 'Infinity' },
+          { type: 'Array', val: [] },
+          { type: 'null', val: null },
+          { type: 'undefined', val: undefined },
+          { type: 'Boolean', val: true },
+          { type: 'Object', val: {} },
+          { type: 'Symbol', val: Symbol.iterator, errVal: 'Symbol(Symbol.iterator)' },
+        ], (attrs) => {
+          it(`throws when 1st arg is ${attrs.type}`, (done) => {
+            cy.on('fail', (err) => {
+              expect(err.message).to.eq(`\`cy.wait()\` only accepts a number, an alias of a route, or an array of aliases of routes. You passed: \`${attrs.errVal || JSON.stringify(attrs.val)}\``)
+              expect(err.docsUrl).to.eq('https://on.cypress.io/wait')
+
+              done()
+            })
+
+            cy.get('body').wait(attrs.val)
+          })
+        })
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('can turn off logging', () => {
+        cy.wait(10, { log: false }).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog).to.be.undefined
+        })
+      })
+
+      describe('number argument', () => {
+        it('does not immediately end', () => {
+          cy.on('log:added', (attrs, log) => {
+            if (attrs.name === 'wait') {
+              expect(log.get('state')).not.to.eq('passed')
             }
-          ]);}));
+          })
 
-      it("#consoleProps waiting on 1 alias", () => cy
-        .server()
-        .route(/foo/, {}).as("getFoo")
-        .window().then(function(win) {
-          xhrGet(win, "/foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-            Command: "wait",
-            "Waited For": "getFoo",
-            Yielded: xhr
-          });}));
-
-      return it("#consoleProps waiting on multiple aliases", () => cy
-        .server()
-        .route(/foo/, {}).as("getFoo")
-        .route(/bar/, {}).as("getBar")
-        .window().then(function(win) {
-          xhrGet(win, "/foo");
-          xhrGet(win, "/bar");
-          return null;}).wait(["@getFoo", "@getBar"]).then(function(xhrs) {
-          return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-            Command: "wait",
-            "Waited For": "getFoo, getBar",
-            Yielded: [xhrs[0], xhrs[1]] //# explictly create the array here
-          });}));
-  });
-});
-}));
-
-      // describe "function argument", ->
-      //   it "#consoleProps", ->
-      //     retriedThreeTimes = false
-
-      //     retry = _.after 3, ->
-      //       retriedThreeTimes = true
-
-      //     cy.on "command:retry", retry
-
-      //     fn = ->
-      //       expect(retriedThreeTimes).to.be.true;
-
-      //     cy
-      //       .wait(fn).then ->
-      //         expect(@lastLog.invoke("consoleProps")).to.deep.eq {
-      //           Command: "wait"
-      //           "Waited For": _.str.clean(fn.toString())
-      //           Retried: "3 times"
-      //         }
+          cy.noop({}).wait(10).then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('state')).to.eq('passed')
+          })
+        })
+
+        it('does not immediately snapshot', () => {
+          cy.on('log:added', (attrs, log) => {
+            if (attrs.name === 'wait') {
+              expect(log.get('snapshots')).not.to.be.ok
+            }
+          })
+
+          cy.noop({}).wait(10).then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('snapshots').length).to.eq(1)
+            expect(lastLog.get('snapshots')[0]).to.be.an('object')
+          })
+        })
+
+        it('is a type: child if subject', () => {
+          cy.noop({}).wait(10).then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('type')).to.eq('child')
+          })
+        })
+
+        it('is a type: child if subject is false', () => {
+          cy.noop(false).wait(10).then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('type')).to.eq('child')
+          })
+        })
+
+        it('is a type: parent if subject is null or undefined', () => {
+          cy.wait(10).then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('type')).to.eq('parent')
+          })
+        })
+
+        it('#consoleProps', () => {
+          cy.wait(10).then(function () {
+            expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+              Command: 'wait',
+              'Waited For': '10ms before continuing',
+              'Yielded': undefined,
+            })
+          })
+        })
+
+        it('#consoleProps as a child', () => {
+          cy.wrap({}).wait(10).then(function () {
+            expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+              Command: 'wait',
+              'Waited For': '10ms before continuing',
+              'Yielded': {},
+            })
+          })
+        })
+      })
+
+      describe('alias argument errors', () => {
+        it('.log', function (done) {
+          Cypress.config('requestTimeout', 100)
+
+          cy.on('fail', (err) => {
+            const obj = {
+              name: 'wait',
+              referencesAlias: [{ name: 'getFoo', cardinal: 1, ordinal: '1st' }],
+              aliasType: 'route',
+              type: 'parent',
+              error: err,
+              instrument: 'command',
+              message: '@getFoo',
+            }
+
+            const { lastLog } = this
+
+            _.each(obj, (value, key) => {
+              expect(lastLog.get(key)).deep.eq(value, `expected key: ${key} to eq value: ${value}`)
+            })
+
+            done()
+          })
+
+          cy.server()
+          cy.route(/foo/, {}).as('getFoo')
+          cy.noop({}).wait('@getFoo')
+        })
+
+        it('only logs once', function (done) {
+          cy.on('fail', (err) => {
+            expect(this.logs.length).to.eq(1)
+            expect(err.message).to.eq('`cy.wait()` could not find a registered alias for: `@foo`.\nYou have not aliased anything yet.')
+
+            done()
+          })
+
+          cy.wait('@foo')
+        })
+
+        it('#consoleProps multiple aliases', function (done) {
+          Cypress.config('requestTimeout', 100)
+
+          cy.on('fail', (err) => {
+            const { lastLog } = this
+
+            expect(lastLog.get('error')).to.eq(err)
+            expect(err.message).to.include('`cy.wait()` timed out waiting `100ms` for the 1st request to the route: `getBar`. No request ever occurred.')
+
+            done()
+          })
+
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .route(/bar/, {}).as('getBar')
+          .window().then((win) => {
+            xhrGet(win, '/foo')
+
+            return null
+          })
+          .wait(['@getFoo', '@getBar'])
+        })
+      })
+
+      describe('function argument errors', () => {
+        it('.log')
+
+        it('#consoleProps')
+      })
+
+      describe('alias argument', () => {
+        it('is a parent command', () => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .window().then((win) => {
+            xhrGet(win, '/foo')
+
+            return null
+          })
+          .wait('@getFoo').then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.get('type')).to.eq('parent')
+          })
+        })
+
+        it('passes as array of referencesAlias', () => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .route(/bar/, {}).as('getBar')
+          .window().then((win) => {
+            xhrGet(win, '/foo')
+            xhrGet(win, '/bar')
+            xhrGet(win, '/foo')
+
+            return null
+          })
+          .wait(['@getFoo', '@getBar', '@getFoo']).then(function (xhrs) {
+            const { lastLog } = this
+
+            expect(lastLog.get('referencesAlias')).to.deep.eq([
+              {
+                name: 'getFoo',
+                cardinal: 1,
+                ordinal: '1st',
+              },
+              {
+                name: 'getBar',
+                cardinal: 1,
+                ordinal: '1st',
+              },
+              {
+                name: 'getFoo',
+                cardinal: 2,
+                ordinal: '2nd',
+              },
+            ])
+          })
+        })
+
+        it('#consoleProps waiting on 1 alias', () => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .window().then((win) => {
+            xhrGet(win, '/foo')
+
+            return null
+          })
+          .wait('@getFoo').then(function (xhr) {
+            expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+              Command: 'wait',
+              'Waited For': 'getFoo',
+              Yielded: xhr,
+            })
+          })
+        })
+
+        it('#consoleProps waiting on multiple aliases', () => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .route(/bar/, {}).as('getBar')
+          .window().then((win) => {
+            xhrGet(win, '/foo')
+            xhrGet(win, '/bar')
+
+            return null
+          })
+          .wait(['@getFoo', '@getBar']).then(function (xhrs) {
+            expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+              Command: 'wait',
+              'Waited For': 'getFoo, getBar',
+              Yielded: [xhrs[0], xhrs[1]], // explictly create the array here
+            })
+          })
+        })
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/window_spec.js b/packages/driver/test/cypress/integration/commands/window_spec.js
index e50855cbc8f1..9be848b59351 100644
--- a/packages/driver/test/cypress/integration/commands/window_spec.js
+++ b/packages/driver/test/cypress/integration/commands/window_spec.js
@@ -1,920 +1,993 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const $ = Cypress.$.bind(Cypress);
-const {
-  _
-} = Cypress;
+const $ = Cypress.$.bind(Cypress)
+const { _ } = Cypress
 
-describe("src/cy/commands/window", function() {
-  context("#window", function() {
-    it("returns the remote window", () => cy.window().then(win => expect(win).to.eq(cy.state("$autIframe").prop("contentWindow"))));
+describe('src/cy/commands/window', () => {
+  context('#window', () => {
+    it('returns the remote window', () => {
+      cy.window().then((win) => {
+        expect(win).to.eq(cy.state('$autIframe').prop('contentWindow'))
+      })
+    })
 
-    describe("assertion verification", function() {
-      beforeEach(function() {
-        this.remoteWindow = cy.state("window");
+    describe('assertion verification', () => {
+      beforeEach(function () {
+        this.remoteWindow = cy.state('window')
 
-        delete this.remoteWindow.foo;
+        delete this.remoteWindow.foo
 
-        Cypress.config("defaultCommandTimeout", 100);
+        Cypress.config('defaultCommandTimeout', 100)
 
-        this.logs = [];
+        this.logs = []
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('eventually passes the assertion', function () {
+        cy.on('command:retry', _.after(2, () => {
+          this.remoteWindow.foo = 'bar'
+        }))
 
-        return null;
-      });
+        cy.window().should('have.property', 'foo', 'bar').then(function () {
+          const { lastLog } = this
 
-      it("eventually passes the assertion", function() {
-        cy.on("command:retry", _.after(2, () => {
-          return this.remoteWindow.foo = "bar";
+          expect(lastLog.get('name')).to.eq('assert')
+          expect(lastLog.get('state')).to.eq('passed')
+          expect(lastLog.get('ended')).to.be.true
         })
-        );
+      })
 
-        return cy.window().should("have.property", "foo", "bar").then(function() {
-          const {
-            lastLog
-          } = this;
+      it('eventually fails the assertion', function (done) {
+        cy.on('command:retry', _.after(2, () => {
+          this.remoteWindow.foo = 'foo'
+        }))
 
-          expect(lastLog.get("name")).to.eq("assert");
-          expect(lastLog.get("state")).to.eq("passed");
-          return expect(lastLog.get("ended")).to.be.true;
-        });
-      });
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      it("eventually fails the assertion", function(done) {
-        cy.on("command:retry", _.after(2, () => {
-          return this.remoteWindow.foo = "foo";
-        })
-        );
+          expect(err.message).to.include(lastLog.get('error').message)
+          expect(err.message).not.to.include('undefined')
+          expect(lastLog.get('name')).to.eq('assert')
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(lastLog.get('error')).to.be.an.instanceof(chai.AssertionError)
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+          done()
+        })
 
-          expect(err.message).to.include(lastLog.get("error").message);
-          expect(err.message).not.to.include("undefined");
-          expect(lastLog.get("name")).to.eq("assert");
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(lastLog.get("error")).to.be.an.instanceof(chai.AssertionError);
+        cy.window().should('have.property', 'foo', 'bar')
+      })
 
-          return done();
-        });
+      it('can still fail on window', function (done) {
+        const win = cy.state('window')
 
-        return cy.window().should("have.property", "foo", "bar");
-      });
+        cy.state('window', undefined)
 
-      it("can still fail on window", function(done) {
-        const win = cy.state("window");
+        cy.on('fail', (err) => {
+          cy.state('window', win)
 
-        cy.state("window", undefined);
+          const { lastLog } = this
 
-        cy.on("fail", err => {
-          cy.state("window", win);
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.include(lastLog.get('error').message)
+          expect(lastLog.get('name')).to.eq('window')
+          expect(lastLog.get('state')).to.eq('failed')
 
-          const {
-            lastLog
-          } = this;
+          done()
+        })
 
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.include(lastLog.get("error").message);
-          expect(lastLog.get("name")).to.eq("window");
-          expect(lastLog.get("state")).to.eq("failed");
+        cy.window()
+      })
 
-          return done();
-        });
+      it('does not log an additional log on failure', function (done) {
+        this.remoteWindow.foo = 'foo'
 
-        return cy.window();
-      });
+        cy.on('fail', () => {
+          expect(this.logs.length).to.eq(2)
 
-      return it("does not log an additional log on failure", function(done) {
-        this.remoteWindow.foo = "foo";
+          done()
+        })
 
-        cy.on("fail", () => {
-          expect(this.logs.length).to.eq(2);
-          return done();
-        });
+        cy.window().should('have.property', 'foo', 'bar')
+      })
+    })
 
-        return cy.window().should("have.property", "foo", "bar");
-      });
-    });
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
 
-    return describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+        return null
+      })
 
-        return null;
-      });
+      it('can turn off logging', () => {
+        cy.window({ log: false }).then(function () {
+          expect(this.log).to.be.undefined
+        })
+      })
 
-      it("can turn off logging", () => cy.window({log: false}).then(function() {
-        return expect(this.log).to.be.undefined;
-      }));
+      it('logs immediately before resolving', (done) => {
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'window') {
+            expect(log.get('state')).to.eq('pending')
+            expect(log.get('snapshot')).not.to.be.ok
 
-      it("logs immediately before resolving", function(done) {
-        cy.on("log:added", function(attrs, log) {
-          if (attrs.name === "window") {
-            expect(log.get("state")).to.eq("pending");
-            expect(log.get("snapshot")).not.to.be.ok;
-            return done();
+            done()
           }
-        });
+        })
 
-        return cy.window();
-      });
+        cy.window()
+      })
 
-      it("snapshots after resolving", () => cy.window().then(function() {
-        const {
-          lastLog
-        } = this;
+      it('snapshots after resolving', () => {
+        cy.window().then(function () {
+          const { lastLog } = this
 
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      }));
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
 
-      it("can be aliased", () => cy
-        .window().as("win")
-        .get("body")
-        .get("@win").then(function(win) {
-          //# window + get + get
-          expect(this.logs.length).to.eq(3);
+      it('can be aliased', () => {
+        return cy
+        .window().as('win')
+        .get('body')
+        .get('@win').then(function (win) {
+        // window + get + get
+          expect(this.logs.length).to.eq(3)
 
-          expect(win).to.eq(this.win);
+          expect(win).to.eq(this.win)
 
-          expect(this.logs[0].get("alias")).to.eq("win");
-          expect(this.logs[0].get("aliasType")).to.eq("primitive");
+          expect(this.logs[0].get('alias')).to.eq('win')
+          expect(this.logs[0].get('aliasType')).to.eq('primitive')
 
-          expect(this.logs[2].get("aliasType")).to.eq("primitive");
-          return expect(this.logs[2].get("referencesAlias").name).to.eq("win");
-      }));
+          expect(this.logs[2].get('aliasType')).to.eq('primitive')
+          expect(this.logs[2].get('referencesAlias').name).to.eq('win')
+        })
+      })
+
+      it('logs obj', () => {
+        cy.window().then(function () {
+          const obj = {
+            name: 'window',
+            message: '',
+          }
 
-      it("logs obj", () => cy.window().then(function() {
-        const obj = {
-          name: "window",
-          message: ""
-        };
+          const { lastLog } = this
 
-        const {
-          lastLog
-        } = this;
+          _.each(obj, (value, key) => {
+            expect(lastLog.get(key)).to.deep.eq(value)
+          })
+        })
+      })
+
+      it('#consoleProps', () => {
+        cy.window().then(function (win) {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'window',
+            Yielded: win,
+          })
+        })
+      })
+    })
+  })
 
-        return _.each(obj, (value, key) => {
-          return expect(lastLog.get(key)).to.deep.eq(value);
-        });
-      }));
+  context('#document', () => {
+    it('returns the remote document as a jquery object', () => {
+      cy.document().then(($doc) => {
+        expect($doc).to.eq(cy.state('$autIframe').prop('contentDocument'))
+      })
+    })
 
-      return it("#consoleProps", () => cy.window().then(function(win) {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "window",
-          Yielded: win
-        });}));
-  });
-});
+    describe('assertion verification', () => {
+      beforeEach(function () {
+        this.remoteDocument = cy.state('window').document
 
-  context("#document", function() {
-    it("returns the remote document as a jquery object", () => cy.document().then($doc => expect($doc).to.eq(cy.state("$autIframe").prop("contentDocument"))));
+        delete this.remoteDocument.foo
 
-    describe("assertion verification", function() {
-      beforeEach(function() {
-        this.remoteDocument = cy.state("window").document;
+        Cypress.config('defaultCommandTimeout', 100)
 
-        delete this.remoteDocument.foo;
+        this.logs = []
 
-        Cypress.config("defaultCommandTimeout", 100);
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('eventually passes the assertion', function () {
+        cy.on('command:retry', _.after(2, () => {
+          this.remoteDocument.foo = 'bar'
+        }))
+
+        cy.document().should('have.property', 'foo', 'bar').then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('name')).to.eq('assert')
+          expect(lastLog.get('state')).to.eq('passed')
+          expect(lastLog.get('ended')).to.be.true
+        })
+      })
 
-        this.logs = [];
+      it('eventually fails the assertion', function (done) {
+        cy.on('command:retry', _.after(2, () => {
+          this.remoteDocument.foo = 'foo'
+        }))
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-        return null;
-      });
+          expect(err.message).to.include(lastLog.get('error').message)
+          expect(err.message).not.to.include('undefined')
+          expect(lastLog.get('name')).to.eq('assert')
+          expect(lastLog.get('state')).to.eq('failed')
+          expect(lastLog.get('error')).to.be.an.instanceof(chai.AssertionError)
 
-      it("eventually passes the assertion", function() {
-        cy.on("command:retry", _.after(2, () => {
-          return this.remoteDocument.foo = "bar";
+          done()
         })
-        );
 
-        return cy.document().should("have.property", "foo", "bar").then(function() {
-          const {
-            lastLog
-          } = this;
+        cy.document().should('have.property', 'foo', 'bar')
+      })
 
-          expect(lastLog.get("name")).to.eq("assert");
-          expect(lastLog.get("state")).to.eq("passed");
-          return expect(lastLog.get("ended")).to.be.true;
-        });
-      });
+      it('can still fail on document', function (done) {
+        const win = cy.state('window')
 
-      it("eventually fails the assertion", function(done) {
-        cy.on("command:retry", _.after(2, () => {
-          return this.remoteDocument.foo = "foo";
+        cy.state('window', undefined)
+
+        cy.on('fail', (err) => {
+          cy.state('window', win)
+
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.include(lastLog.get('error').message)
+          expect(lastLog.get('name')).to.eq('document')
+          expect(lastLog.get('state')).to.eq('failed')
+
+          done()
         })
-        );
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+        cy.document()
+      })
+
+      it('does not log an additional log on failure', function (done) {
+        this.remoteDocument.foo = 'foo'
 
-          expect(err.message).to.include(lastLog.get("error").message);
-          expect(err.message).not.to.include("undefined");
-          expect(lastLog.get("name")).to.eq("assert");
-          expect(lastLog.get("state")).to.eq("failed");
-          expect(lastLog.get("error")).to.be.an.instanceof(chai.AssertionError);
+        cy.on('fail', () => {
+          expect(this.logs.length).to.eq(2)
 
-          return done();
-        });
+          done()
+        })
 
-        return cy.document().should("have.property", "foo", "bar");
-      });
+        cy.document().should('have.property', 'foo', 'bar')
+      })
+    })
 
-      it("can still fail on document", function(done) {
-        const win = cy.state("window");
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
 
-        cy.state("window", undefined);
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
 
-        cy.on("fail", err => {
-          cy.state("window", win);
+        return null
+      })
 
-          const {
-            lastLog
-          } = this;
+      it('can turn off logging', () => {
+        cy.document({ log: false }).then(function () {
+          expect(this.log).to.be.undefined
+        })
+      })
 
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.include(lastLog.get("error").message);
-          expect(lastLog.get("name")).to.eq("document");
-          expect(lastLog.get("state")).to.eq("failed");
+      it('logs immediately before resolving', (done) => {
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'document') {
+            expect(log.get('state')).to.eq('pending')
+            expect(log.get('snapshots')).not.to.be.ok
 
-          return done();
-        });
+            done()
+          }
+        })
 
-        return cy.document();
-      });
+        cy.document()
+      })
 
-      return it("does not log an additional log on failure", function(done) {
-        this.remoteDocument.foo = "foo";
+      it('snapshots after resolving', () => {
+        cy.document().then(function () {
+          const { lastLog } = this
 
-        cy.on("fail", () => {
-          expect(this.logs.length).to.eq(2);
-          return done();
-        });
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
 
-        return cy.document().should("have.property", "foo", "bar");
-      });
-    });
+      it('can be aliased', function () {
+        const logs = []
 
-    return describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
+        cy.on('log:added', (attrs, log) => {
+          this.log = log
+          logs.push(this.log)
+        })
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+        cy
+        .document().as('doc')
+        .get('body')
+        .get('@doc').then(function (doc) {
+          // docdow + get + get
+          expect(this.logs.length).to.eq(3)
 
-        return null;
-      });
+          expect(doc).to.eq(this.doc)
 
-      it("can turn off logging", () => cy.document({log: false}).then(function() {
-        return expect(this.log).to.be.undefined;
-      }));
+          expect(logs[0].get('alias')).to.eq('doc')
+          expect(logs[0].get('aliasType')).to.eq('primitive')
 
-      it("logs immediately before resolving", function(done) {
-        cy.on("log:added", function(attrs, log) {
-          if (attrs.name === "document") {
-            expect(log.get("state")).to.eq("pending");
-            expect(log.get("snapshots")).not.to.be.ok;
-            return done();
+          expect(logs[2].get('aliasType')).to.eq('primitive')
+          expect(logs[2].get('referencesAlias').name).to.eq('doc')
+        })
+      })
+
+      it('logs obj', () => {
+        cy.document().then(function () {
+          const obj = {
+            name: 'document',
+            message: '',
           }
-        });
 
-        return cy.document();
-      });
+          const { lastLog } = this
+
+          _.each(obj, (value, key) => {
+            expect(lastLog.get(key)).to.deep.eq(value)
+          })
+        })
+      })
+
+      it('#consoleProps', () => {
+        cy.document().then(function (win) {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'document',
+            Yielded: win,
+          })
+        })
+      })
+    })
+  })
 
-      it("snapshots after resolving", () => cy.document().then(function() {
-        const {
-          lastLog
-        } = this;
+  context('#title', () => {
+    before(() => {
+      cy
+      .visit('/fixtures/generic.html')
+      .then(function (win) {
+        const h = $(win.document.head)
 
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      }));
+        h.find('script').remove()
 
-      it("can be aliased", function() {
-        const logs = [];
+        this.head = h.prop('outerHTML')
+        this.body = win.document.body.outerHTML
+      })
+    })
 
-        cy.on("log:added", (attrs, log) => {
-          this.log = log;
-          return logs.push(this.log);
-        });
+    beforeEach(function () {
+      const doc = cy.state('document')
 
-        return cy
-          .document().as("doc")
-          .get("body")
-          .get("@doc").then(function(doc) {
-            //# docdow + get + get
-            expect(this.logs.length).to.eq(3);
-
-            expect(doc).to.eq(this.doc);
-
-            expect(logs[0].get("alias")).to.eq("doc");
-            expect(logs[0].get("aliasType")).to.eq("primitive");
-
-            expect(logs[2].get("aliasType")).to.eq("primitive");
-            return expect(logs[2].get("referencesAlias").name).to.eq("doc");
-        });
-      });
-
-      it("logs obj", () => cy.document().then(function() {
-        const obj = {
-          name: "document",
-          message: ""
-        };
-
-        const {
-          lastLog
-        } = this;
-
-        return _.each(obj, (value, key) => {
-          return expect(lastLog.get(key)).to.deep.eq(value);
-        });
-      }));
-
-      return it("#consoleProps", () => cy.document().then(function(win) {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "document",
-          Yielded: win
-        });}));
-  });
-});
-
-  context("#title", function() {
-    before(() => cy
-      .visit("/fixtures/generic.html")
-      .then(function(win) {
-        const h = $(win.document.head);
-        h.find("script").remove();
-
-        this.head = h.prop("outerHTML");
-        return this.body = win.document.body.outerHTML;
-    }));
-
-    beforeEach(function() {
-      const doc = cy.state("document");
-
-      $(doc.head).empty().html(this.head);
-      return $(doc.body).empty().html(this.body);
-    });
-
-    it("returns the pages title as a string", function() {
-      const title = cy.$$("title").text();
-      return cy.title().then(text => expect(text).to.eq(title));
-    });
-
-    it("retries finding the title", function() {
-      cy.$$("title").remove();
+      $(doc.head).empty().html(this.head)
+      $(doc.body).empty().html(this.body)
+    })
+
+    it('returns the pages title as a string', () => {
+      const title = cy.$$('title').text()
+
+      cy.title().then((text) => {
+        expect(text).to.eq(title)
+      })
+    })
+
+    it('retries finding the title', () => {
+      cy.$$('title').remove()
 
       const retry = _.after(2, () => {
-        return cy.$$("head").append($("<title>waiting on title</title>"));
-      });
+        cy.$$('head').append($('<title>waiting on title</title>'))
+      })
+
+      cy.on('command:retry', retry)
+
+      cy.title().should('eq', 'waiting on title')
+    })
 
-      cy.on("command:retry", retry);
+    it('eventually resolves', () => {
+      _.delay(() => {
+        cy.$$('title').text('about page')
+      }, 100)
 
-      return cy.title().should("eq", "waiting on title");
-    });
+      cy.title().should('eq', 'about page').and('match', /about/)
+    })
 
-    it("eventually resolves", function() {
-      _.delay(() => cy.$$("title").text("about page")
-      , 100);
+    it('uses the first title element', () => {
+      cy.$$('head').prepend('<title>some title</title>')
+      cy.$$('head').prepend('<title>another title</title>')
 
-      return cy.title().should("eq", "about page").and("match", /about/);
-    });
+      cy.title().then(($title) => {
+        expect($title).to.eq('another title')
+      })
+    })
 
-    it("uses the first title element", function() {
-      const title = cy.$$("head title").text();
+    it('uses document.title setter over <title>', () => {
+      const title = cy.$$('title')
 
-      cy.$$("head").prepend("<title>some title</title>");
-      cy.$$("head").prepend("<title>another title</title>");
+      // make sure we have a title element
+      expect(title.length).to.eq(1)
+      expect(title.text()).not.to.eq('foo')
 
-      return cy.title().then($title => expect($title).to.eq("another title"));
-    });
+      cy.state('document').title = 'foo'
 
-    it("uses document.title setter over <title>", function() {
-      const title = cy.$$("title");
+      cy.title().then((title) => {
+        expect(title).to.eq('foo')
+      })
+    })
 
-      //# make sure we have a title element
-      expect(title.length).to.eq(1);
-      expect(title.text()).not.to.eq("foo");
+    it('is empty string when no <title>', () => {
+      cy.$$('title').remove()
 
-      cy.state("document").title = "foo";
+      cy.title().then(($title) => {
+        expect($title).to.eq('')
+      })
+    })
 
-      return cy.title().then(title => expect(title).to.eq("foo"));
-    });
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
 
-    it("is empty string when no <title>", function() {
-      cy.$$("title").remove();
+        this.logs = []
 
-      return cy.title().then($title => expect($title).to.eq(""));
-    });
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('throws after timing out', (done) => {
+        cy.$$('title').remove()
 
-    describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 50);
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('expected \'\' to equal \'asdf\'')
 
-        this.logs = [];
+          done()
+        })
+
+        cy.title().should('eq', 'asdf')
+      })
 
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
+      it('only logs once', function (done) {
+        cy.$$('title').remove()
 
-        return null;
-      });
+        cy.on('fail', (err) => {
+          const { lastLog } = this
 
-      it("throws after timing out", function(done) {
-        cy.$$("title").remove();
+          expect(this.logs.length).to.eq(2)
+          expect(err.message).to.include(lastLog.get('error').message)
 
-        cy.on("fail", err => {
-          expect(err.message).to.include("expected '' to equal 'asdf'");
-          return done();
-        });
+          done()
+        })
 
-        return cy.title().should("eq", "asdf");
-      });
+        cy.title().should('eq', 'asdf')
+      })
+    })
 
-      return it("only logs once", function(done) {
-        cy.$$("title").remove();
+    describe('.log', () => {
+      beforeEach(function () {
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
 
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
+          if (log.get('name') === 'get') {
+            throw new Error('`cy.get()` should not have logged out.')
+          }
+        })
 
-          expect(this.logs.length).to.eq(2);
-          expect(err.message).to.include(lastLog.get("error").message);
-          return done();
-        });
+        return null
+      })
 
-        return cy.title().should("eq", "asdf");
-      });
-    });
+      it('can turn off logging', () => {
+        cy.title({ log: false }).then(function () {
+          expect(this.log).to.be.undefined
+        })
+      })
 
-    return describe(".log", function() {
-      beforeEach(function() {
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
+      it('logs immediately before resolving', (done) => {
+        cy.on('log:added', (attrs, log) => {
+          if (log.get('name') === 'title') {
+            expect(log.get('state')).to.eq('pending')
 
-          if (log.get("name") === "get") {
-            throw new Error("`cy.get()` should not have logged out.");
+            done()
           }
-        });
+        })
 
-        return null;
-      });
+        cy.title()
+      })
 
-      it("can turn off logging", () => cy.title({log: false}).then(function() {
-        return expect(this.log).to.be.undefined;
-      }));
+      it('snapshots after clicking', () => {
+        cy.title().then(function () {
+          const { lastLog } = this
 
-      it("logs immediately before resolving", function(done) {
-        const input = cy.$$(":text:first");
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
 
-        cy.on("log:added", function(attrs, log) {
-          if (log.get("name") === "title") {
-            expect(log.get("state")).to.eq("pending");
-            return done();
+      it('logs obj', () => {
+        cy.title().then(function () {
+          const obj = {
+            name: 'title',
           }
-        });
-
-        return cy.title();
-      });
-
-      it("snapshots after clicking", () => cy.title().then(function() {
-        const {
-          lastLog
-        } = this;
-
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      }));
-
-      it("logs obj", () => cy.title().then(function() {
-        const obj = {
-          name: "title"
-        };
-
-        const {
-          lastLog
-        } = this;
-
-        return _.each(obj, (value, key) => {
-          return expect(lastLog.get(key)).to.deep.eq(value);
-        });
-      }));
-
-      return it("#consoleProps", () => cy.title().then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "title",
-          Yielded: "Generic HTML Fixture"
-        });}));
-  });
-});
-
-  return context("#viewport", function() {
-    it("triggers 'viewport:changed' event with dimensions object", function() {
-      let expected = false;
-
-      cy.on("viewport:changed", function(viewport, fn) {
-        expected = true;
-        expect(viewport).to.deep.eq({viewportWidth: 800, viewportHeight: 600});
-        return expect(fn).to.be.a("function");
-      });
-
-      return cy.viewport(800, 600).then(() => expect(expected).to.be.true);
-    });
-
-    it("does not trigger 'viewport:changed' when changing to the default", function() {
-      const fn = function() {
-        throw new Error("Should not trigger 'viewport:changed'");
-      };
-
-      Cypress.prependListener("viewport:changed", fn);
-
-      return cy.viewport(1000, 660).then(() => Cypress.removeListener("viewport:changed", fn));
-    });
-
-    it("does not trigger 'viewport:changed' when changing to the same viewport", function() {
-      let triggeredOnce = false;
-      const fn = function() {
+
+          const { lastLog } = this
+
+          _.each(obj, (value, key) => {
+            expect(lastLog.get(key)).to.deep.eq(value)
+          })
+        })
+      })
+
+      it('#consoleProps', () => {
+        cy.title().then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'title',
+            Yielded: 'Generic HTML Fixture',
+          })
+        })
+      })
+    })
+  })
+
+  context('#viewport', () => {
+    it('triggers \'viewport:changed\' event with dimensions object', () => {
+      let expected = false
+
+      cy.on('viewport:changed', (viewport, fn) => {
+        expected = true
+        expect(viewport).to.deep.eq({ viewportWidth: 800, viewportHeight: 600 })
+        expect(fn).to.be.a('function')
+      })
+
+      cy.viewport(800, 600).then(() => {
+        expect(expected).to.be.true
+      })
+    })
+
+    it('does not trigger \'viewport:changed\' when changing to the default', () => {
+      const fn = function () {
+        throw new Error('Should not trigger \'viewport:changed\'')
+      }
+
+      Cypress.prependListener('viewport:changed', fn)
+
+      cy.viewport(1000, 660).then(() => {
+        return Cypress.removeListener('viewport:changed', fn)
+      })
+    })
+
+    it('does not trigger \'viewport:changed\' when changing to the same viewport', () => {
+      let triggeredOnce = false
+      const fn = function () {
         if (triggeredOnce) {
-          throw new Error("Should not trigger 'viewport:changed'");
+          throw new Error('Should not trigger \'viewport:changed\'')
         }
-        return triggeredOnce = true;
-      };
 
-      Cypress.prependListener("viewport:changed", fn);
+        triggeredOnce = true
+      }
+
+      Cypress.prependListener('viewport:changed', fn)
 
-      cy.viewport(800, 600);
-      return cy.viewport(800, 600).then(() => Cypress.removeListener("viewport:changed", fn));
-    });
+      cy.viewport(800, 600)
+      cy.viewport(800, 600).then(() => {
+        return Cypress.removeListener('viewport:changed', fn)
+      })
+    })
 
-    it("triggers 'viewport:changed' if width changes", function(done) {
-      let finished = false;
-      setTimeout(function() {
+    it('triggers \'viewport:changed\' if width changes', (done) => {
+      let finished = false
+
+      setTimeout(() => {
         if (!finished) {
-          return done("Timed out before 'viewport:changed'");
+          return done('Timed out before \'viewport:changed\'')
         }
-      }
-      , 1000);
-      let triggeredOnce = false;
-      cy.on("viewport:changed", function(viewport) {
+      }, 1000)
+
+      let triggeredOnce = false
+
+      cy.on('viewport:changed', (viewport) => {
         if (triggeredOnce) {
-          expect(viewport).to.eql({ viewportWidth: 900, viewportHeight: 600 });
-          finished = true;
-          done();
+          expect(viewport).to.eql({ viewportWidth: 900, viewportHeight: 600 })
+          finished = true
+          done()
         }
-        return triggeredOnce = true;
-      });
 
-      cy.viewport(800, 600);
-      return cy.viewport(900, 600);
-    });
+        triggeredOnce = true
+      })
+
+      cy.viewport(800, 600)
+      cy.viewport(900, 600)
+    })
 
-    it("triggers 'viewport:changed' if height changes", function(done) {
-      let finished = false;
-      setTimeout(function() {
+    it('triggers \'viewport:changed\' if height changes', (done) => {
+      let finished = false
+
+      setTimeout(() => {
         if (!finished) {
-          return done("Timed out before 'viewport:changed'");
+          return done('Timed out before \'viewport:changed\'')
         }
-      }
-      , 1000);
-      let triggeredOnce = false;
-      cy.on("viewport:changed", function(viewport) {
+      }, 1000)
+
+      let triggeredOnce = false
+
+      cy.on('viewport:changed', (viewport) => {
         if (triggeredOnce) {
-          expect(viewport).to.eql({ viewportWidth: 800, viewportHeight: 700 });
-          finished = true;
-          done();
+          expect(viewport).to.eql({ viewportWidth: 800, viewportHeight: 700 })
+          finished = true
+          done()
         }
-        return triggeredOnce = true;
-      });
-
-      cy.viewport(800, 600);
-      return cy.viewport(800, 700);
-    });
-
-    it("sets subject to null", () => cy.viewport("ipad-2").then(subject => expect(subject).to.be.null));
-
-    it("does not modify viewportWidth and viewportHeight in config", function() {
-      let expected = false;
-      cy.on("viewport:changed", function() {
-        expected = true;
-        expect(Cypress.config("viewportWidth")).not.to.eq(800);
-        return expect(Cypress.config("viewportHeight")).not.to.eq(600);
-      });
-
-      return cy.viewport(800, 600).then(() => expect(expected).to.be.true);
-    });
-
-    context("changing viewport", () => it("changes viewport and then resets back to the original", function() {
-      const { viewportHeight, viewportWidth } = Cypress.config();
-
-      return cy.viewport(500, 400).then(() => Cypress.action("runner:test:before:run:async", {})
-      .then(function() {
-        expect(Cypress.config("viewportWidth")).to.eq(viewportWidth);
-        return expect(Cypress.config("viewportHeight")).to.eq(viewportHeight);
-      }));
-    }));
-
-    context("presets", function() {
-      it("ipad-2", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 768, viewportHeight: 1024});
-          return done();
-        });
-
-        return cy.viewport("ipad-2");
-      });
-
-      it("ipad-mini", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 768, viewportHeight: 1024});
-          return done();
-        });
-
-        return cy.viewport("ipad-mini");
-      });
-
-      it("iphone-xr", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 414, viewportHeight: 896});
-          return done();
-        });
-
-        return cy.viewport("iphone-xr");
-      });
-
-      it("iphone-x", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 375, viewportHeight: 812});
-          return done();
-        });
-
-        return cy.viewport("iphone-x");
-      });
-
-      it("iphone-6+", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 414, viewportHeight: 736});
-          return done();
-        });
-
-        return cy.viewport("iphone-6+");
-      });
-
-      it("iphone-6", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 375, viewportHeight: 667});
-          return done();
-        });
-
-        return cy.viewport("iphone-6");
-      });
-
-      it("iphone-5", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 320, viewportHeight: 568});
-          return done();
-        });
-
-        return cy.viewport("iphone-5");
-      });
-
-      it("can change the orientation to landspace", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 568, viewportHeight: 320});
-          return done();
-        });
-
-        return cy.viewport("iphone-5", "landscape");
-      });
-
-      it("can change the orientation to portrait", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 320, viewportHeight: 568});
-          return done();
-        });
-
-        return cy.viewport("iphone-5", "portrait");
-      });
-
-      it("samsung-s10", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 360, viewportHeight: 760});
-          return done();
-        });
-
-        return cy.viewport("samsung-s10");
-      });
-
-      return it("samsung-note9", function(done) {
-        cy.on("viewport:changed", function(viewport) {
-          expect(viewport).to.deep.eq({viewportWidth: 414, viewportHeight: 846});
-          return done();
-        });
-
-        return cy.viewport("samsung-note9");
-      });
-    });
-
-    context("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 50);
-
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
-
-        return null;
-      });
-
-      it("throws when passed invalid preset", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.match(/^`cy.viewport\(\)` could not find a preset for: `foo`. Available presets are: /);
-          expect(err.docsUrl).to.eq("https://on.cypress.io/viewport");
-          return done();
-        });
-
-        return cy.viewport("foo");
-      });
-
-      it("throws when passed a string as height", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.eq("`cy.viewport()` can only accept a string preset or a `width` and `height` as numbers.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/viewport");
-          return done();
-        });
-
-        return cy.viewport(800, "600");
-      });
-
-      it("throws when passed negative numbers", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.eq("`cy.viewport()` `width` and `height` must be at least 0px.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/viewport");
-          return done();
-        });
-
-        return cy.viewport(800, -600);
-      });
-
-      it("does not throw when passed width equal to 0", () => cy.viewport(0, 600));
-
-      it("does not throw when passed width equal to 1000000", () => cy.viewport(200, 1000000));
-
-      it("throws when passed an empty string as width", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.eq("`cy.viewport()` cannot be passed an empty string.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/viewport");
-          return done();
-        });
-
-        return cy.viewport("");
-      });
-
-      it("throws when passed an invalid orientation on a preset", function(done) {
-        cy.on("fail", err => {
-          expect(this.logs.length).to.eq(1);
-          expect(err.message).to.eq("`cy.viewport()` can only accept `landscape` or `portrait` as valid orientations. Your orientation was: `foobar`");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/viewport");
-          return done();
-        });
-
-        return cy.viewport("iphone-4", "foobar");
-      });
-
-      return _.each([{}, [], NaN, Infinity, null, undefined], val => {
-        return it(`throws when passed the invalid: '${val}' as width`, function(done) {
-          const logs = [];
-
-          cy.on("log:added", (attrs, log) => logs.push(log));
-
-          cy.on("fail", err => {
-            expect(this.logs.length).to.eq(1);
-            expect(err.message).to.eq("`cy.viewport()` can only accept a string preset or a `width` and `height` as numbers.");
-            expect(err.docsUrl).to.eq("https://on.cypress.io/viewport");
-            return done();
-          });
-
-          return cy.viewport(val);
-        });
-      });
-    });
-
-    return context(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
-
-        return null;
-      });
-
-      it("logs viewport", () => cy.viewport(800, 600).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("name")).to.eq("viewport");
-      }));
-
-      it("logs viewport with width, height", () => cy.viewport(800, 600).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("message")).to.eq("800, 600");
-      }));
-
-      it("logs viewport with preset", () => cy.viewport("ipad-2").then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("message")).to.eq("ipad-2");
-      }));
-
-      it("sets state to success immediately", () => cy.viewport(800, 600).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("state")).to.eq("passed");
-      }));
-
-      it("snapshots immediately", () => cy.viewport(800, 600).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        expect(lastLog.get("snapshots").length).to.eq(1);
-        return expect(lastLog.get("snapshots")[0]).to.be.an("object");
-      }));
-
-      it("can turn off logging viewport command", () => cy.viewport(800, 600, {log: false}).then(function() {
-        return expect(this.log).not.to.be.ok;
-      }));
-
-      it("can turn off logging viewport when using preset", () => cy.viewport("macbook-15", {log: false}).then(function() {
-        return expect(this.log).not.to.be.ok;
-      }));
-
-      it("sets viewportWidth and viewportHeight directly", () => cy.viewport(800, 600).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        expect(lastLog.get("viewportWidth")).to.eq(800);
-        return expect(lastLog.get("viewportHeight")).to.eq(600);
-      }));
-
-      it(".consoleProps with preset", () => cy.viewport("ipad-mini").then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "viewport",
-          Preset: "ipad-mini",
-          Width: 768,
-          Height: 1024
-        });}));
-
-      return it(".consoleProps without preset", () => cy.viewport(1024, 768).then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "viewport",
-          Width: 1024,
-          Height: 768
-        });}));
-  });
-});
-});
+
+        triggeredOnce = true
+      })
+
+      cy.viewport(800, 600)
+      cy.viewport(800, 700)
+    })
+
+    it('sets subject to null', () => {
+      cy.viewport('ipad-2').then((subject) => {
+        expect(subject).to.be.null
+      })
+    })
+
+    it('does not modify viewportWidth and viewportHeight in config', () => {
+      let expected = false
+
+      cy.on('viewport:changed', () => {
+        expected = true
+        expect(Cypress.config('viewportWidth')).not.to.eq(800)
+        expect(Cypress.config('viewportHeight')).not.to.eq(600)
+      })
+
+      cy.viewport(800, 600).then(() => {
+        expect(expected).to.be.true
+      })
+    })
+
+    context('changing viewport', () => {
+      it('changes viewport and then resets back to the original', () => {
+        const { viewportHeight, viewportWidth } = Cypress.config()
+
+        cy.viewport(500, 400).then(() => {
+          Cypress.action('runner:test:before:run:async', {})
+          .then(() => {
+            expect(Cypress.config('viewportWidth')).to.eq(viewportWidth)
+            expect(Cypress.config('viewportHeight')).to.eq(viewportHeight)
+          })
+        })
+      })
+    })
+
+    context('presets', () => {
+      it('ipad-2', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 768, viewportHeight: 1024 })
+
+          done()
+        })
+
+        cy.viewport('ipad-2')
+      })
+
+      it('ipad-mini', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 768, viewportHeight: 1024 })
+
+          done()
+        })
+
+        cy.viewport('ipad-mini')
+      })
+
+      it('iphone-xr', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 414, viewportHeight: 896 })
+
+          done()
+        })
+
+        cy.viewport('iphone-xr')
+      })
+
+      it('iphone-x', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 375, viewportHeight: 812 })
+
+          done()
+        })
+
+        cy.viewport('iphone-x')
+      })
+
+      it('iphone-6+', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 414, viewportHeight: 736 })
+
+          done()
+        })
+
+        cy.viewport('iphone-6+')
+      })
+
+      it('iphone-6', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 375, viewportHeight: 667 })
+
+          done()
+        })
+
+        cy.viewport('iphone-6')
+      })
+
+      it('iphone-5', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 320, viewportHeight: 568 })
+
+          done()
+        })
+
+        cy.viewport('iphone-5')
+      })
+
+      it('can change the orientation to landspace', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 568, viewportHeight: 320 })
+
+          done()
+        })
+
+        cy.viewport('iphone-5', 'landscape')
+      })
+
+      it('can change the orientation to portrait', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 320, viewportHeight: 568 })
+
+          done()
+        })
+
+        cy.viewport('iphone-5', 'portrait')
+      })
+
+      it('samsung-s10', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 360, viewportHeight: 760 })
+
+          done()
+        })
+
+        cy.viewport('samsung-s10')
+      })
+
+      it('samsung-note9', (done) => {
+        cy.on('viewport:changed', (viewport) => {
+          expect(viewport).to.deep.eq({ viewportWidth: 414, viewportHeight: 846 })
+
+          done()
+        })
+
+        cy.viewport('samsung-note9')
+      })
+    })
+
+    context('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 50)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('throws when passed invalid preset', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.match(/^`cy.viewport\(\)` could not find a preset for: `foo`. Available presets are: /)
+          expect(err.docsUrl).to.eq('https://on.cypress.io/viewport')
+
+          done()
+        })
+
+        cy.viewport('foo')
+      })
+
+      it('throws when passed a string as height', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.eq('`cy.viewport()` can only accept a string preset or a `width` and `height` as numbers.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/viewport')
+
+          done()
+        })
+
+        cy.viewport(800, '600')
+      })
+
+      it('throws when passed negative numbers', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.eq('`cy.viewport()` `width` and `height` must be at least 0px.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/viewport')
+
+          done()
+        })
+
+        cy.viewport(800, -600)
+      })
+
+      it('does not throw when passed width equal to 0', () => {
+        cy.viewport(0, 600)
+      })
+
+      it('does not throw when passed width equal to 1000000', () => {
+        cy.viewport(200, 1000000)
+      })
+
+      it('throws when passed an empty string as width', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.eq('`cy.viewport()` cannot be passed an empty string.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/viewport')
+
+          done()
+        })
+
+        cy.viewport('')
+      })
+
+      it('throws when passed an invalid orientation on a preset', function (done) {
+        cy.on('fail', (err) => {
+          expect(this.logs.length).to.eq(1)
+          expect(err.message).to.eq('`cy.viewport()` can only accept `landscape` or `portrait` as valid orientations. Your orientation was: `foobar`')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/viewport')
+
+          done()
+        })
+
+        cy.viewport('iphone-4', 'foobar')
+      })
+
+      _.each([{}, [], NaN, Infinity, null, undefined], (val) => {
+        it(`throws when passed the invalid: '${val}' as width`, function (done) {
+          const logs = []
+
+          cy.on('log:added', (attrs, log) => {
+            logs.push(log)
+          })
+
+          cy.on('fail', (err) => {
+            expect(this.logs.length).to.eq(1)
+            expect(err.message).to.eq('`cy.viewport()` can only accept a string preset or a `width` and `height` as numbers.')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/viewport')
+
+            done()
+          })
+
+          cy.viewport(val)
+        })
+      })
+    })
+
+    context('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('logs viewport', () => {
+        cy.viewport(800, 600).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('name')).to.eq('viewport')
+        })
+      })
+
+      it('logs viewport with width, height', () => {
+        cy.viewport(800, 600).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('message')).to.eq('800, 600')
+        })
+      })
+
+      it('logs viewport with preset', () => {
+        cy.viewport('ipad-2').then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('message')).to.eq('ipad-2')
+        })
+      })
+
+      it('sets state to success immediately', () => {
+        cy.viewport(800, 600).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('state')).to.eq('passed')
+        })
+      })
+
+      it('snapshots immediately', () => {
+        cy.viewport(800, 600).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('snapshots').length).to.eq(1)
+          expect(lastLog.get('snapshots')[0]).to.be.an('object')
+        })
+      })
+
+      it('can turn off logging viewport command', () => {
+        cy.viewport(800, 600, { log: false }).then(function () {
+          expect(this.log).not.to.be.ok
+        })
+      })
+
+      it('can turn off logging viewport when using preset', () => {
+        cy.viewport('macbook-15', { log: false }).then(function () {
+          expect(this.log).not.to.be.ok
+        })
+      })
+
+      it('sets viewportWidth and viewportHeight directly', () => {
+        cy.viewport(800, 600).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('viewportWidth')).to.eq(800)
+          expect(lastLog.get('viewportHeight')).to.eq(600)
+        })
+      })
+
+      it('.consoleProps with preset', () => {
+        cy.viewport('ipad-mini').then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'viewport',
+            Preset: 'ipad-mini',
+            Width: 768,
+            Height: 1024,
+          })
+        })
+      })
+
+      it('.consoleProps without preset', () => {
+        cy.viewport(1024, 768).then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'viewport',
+            Width: 1024,
+            Height: 768,
+          })
+        })
+      })
+    })
+  })
+})
diff --git a/packages/driver/test/cypress/integration/commands/xhr_spec.js b/packages/driver/test/cypress/integration/commands/xhr_spec.js
index d9f68b2f738a..97df31ac270d 100644
--- a/packages/driver/test/cypress/integration/commands/xhr_spec.js
+++ b/packages/driver/test/cypress/integration/commands/xhr_spec.js
@@ -1,2299 +1,2809 @@
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-const { _, $, Promise } = Cypress;
-
-describe("src/cy/commands/xhr", function() {
-  before(() => cy
-    .visit("/fixtures/jquery.html")
-    .then(function(win) {
-      const h = $(win.document.head);
-      h.find("script").remove();
-
-      this.head = h.prop("outerHTML");
-      return this.body = win.document.body.outerHTML;
-  }));
-
-  beforeEach(function() {
-    const doc = cy.state("document");
-
-    $(doc.head).empty().html(this.head);
-    return $(doc.body).empty().html(this.body);
-  });
-
-  context("#startXhrServer", function() {
-    it("continues to be a defined properties", () => cy
+const { stripIndent } = require('common-tags')
+const { _, $, Promise } = Cypress
+
+describe('src/cy/commands/xhr', () => {
+  before(() => {
+    cy
+    .visit('/fixtures/jquery.html')
+    .then(function (win) {
+      const h = $(win.document.head)
+
+      h.find('script').remove()
+
+      this.head = h.prop('outerHTML')
+      this.body = win.document.body.outerHTML
+    })
+  })
+
+  beforeEach(function () {
+    const doc = cy.state('document')
+
+    $(doc.head).empty().html(this.head)
+    $(doc.body).empty().html(this.body)
+  })
+
+  context('#startXhrServer', () => {
+    it('continues to be a defined properties', () => {
+      cy
       .server()
-      .route({url: /foo/}).as("getFoo")
-      .window().then(function(win) {
-        const xhr = new win.XMLHttpRequest;
-        xhr.open("GET", "/foo");
-        expect(xhr.onload).to.be.a("function");
-        expect(xhr.onerror).to.be.a("function");
-        return expect(xhr.onreadystatechange).to.be.a("function");
-    }));
-
-    it("prevents infinite recursion", function() {
-      let onloaded = false;
-      let onreadystatechanged = false;
-
-      return cy
-        .server()
-        .route({url: /foo/}).as("getFoo")
-        .window().then(function(win) {
-          const handlers = ["onload", "onerror", "onreadystatechange"];
+      .route({ url: /foo/ }).as('getFoo')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest
+
+        xhr.open('GET', '/foo')
+        expect(xhr.onload).to.be.a('function')
+        expect(xhr.onerror).to.be.a('function')
+        expect(xhr.onreadystatechange).to.be.a('function')
+      })
+    })
+
+    it('prevents infinite recursion', () => {
+      let onloaded = false
+      let onreadystatechanged = false
+
+      cy
+      .server()
+      .route({ url: /foo/ }).as('getFoo')
+      .window().then((win) => {
+        const handlers = ['onload', 'onerror', 'onreadystatechange']
 
-          const wrap = () => handlers.forEach(function(handler) {
-            const bak = xhr[handler];
+        const wrap = () => {
+          handlers.forEach((handler) => {
+            const bak = xhr[handler]
 
-            return xhr[handler] = function() {
+            xhr[handler] = (...args) => {
               if (_.isFunction(bak)) {
-                return bak.apply(xhr, arguments);
+                bak.apply(xhr, args)
               }
-            };
-          });
-
-          var xhr = new win.XMLHttpRequest;
-          xhr.addEventListener("readystatechange", wrap, false);
-          xhr.onreadystatechange = function() {
-            throw new Error("NOOO");
-          };
-          xhr.onreadystatechange;
-          xhr.onreadystatechange = () => onreadystatechanged = true;
-          xhr.open("GET", "/foo");
-          xhr.onload = function() {
-            throw new Error("NOOO");
-          };
-          xhr.onload;
-          xhr.onload = () => onloaded = true;
-          xhr.send();
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(onloaded).to.be.true;
-          expect(onreadystatechanged).to.be.true;
-          return expect(xhr.status).to.eq(404);
-      });
-    });
-
-    //# NOTE: flaky about 50% of the time in Firefox...
-    //# temporarily skipping for now, but this needs
-    //# to be reenabled after launch once we have time
-    //# to look at the underlying failure cause
-    it.skip("allows multiple readystatechange calls", function() {
-      let responseText = null;
-      let responseStatuses = 0;
-
-      return cy
-        .server()
-        .route({ url: /longtext.txt/ }).as("getLongText")
-        .task('create:long:file')
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest();
-          xhr.onreadystatechange = function() {
-            ({
-              responseText
-            } = xhr);
-            if (xhr.readyState === 3) {
-              return responseStatuses++;
             }
-          };
-          xhr.open("GET", "/_test-output/longtext.txt?" + Cypress._.random(0, 1e6));
-          xhr.send();
-          return null;}).wait("@getLongText").then(function(xhr) {
-          expect(responseStatuses).to.be.gt(1);
-          return expect(xhr.status).to.eq(200);
-      });
-    });
-
-    //# https://github.com/cypress-io/cypress/issues/5864
-    it("does not exceed max call stack", () => cy
+          })
+        }
+
+        const xhr = new win.XMLHttpRequest
+
+        xhr.addEventListener('readystatechange', wrap, false)
+        xhr.onreadystatechange = function () {
+          throw new Error('NOOO')
+        }
+
+        xhr.onreadystatechange
+        xhr.onreadystatechange = () => {
+          onreadystatechanged = true
+        }
+
+        xhr.open('GET', '/foo')
+        xhr.onload = function () {
+          throw new Error('NOOO')
+        }
+
+        xhr.onload
+        xhr.onload = () => {
+          onloaded = true
+        }
+
+        xhr.send()
+
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(onloaded).to.be.true
+        expect(onreadystatechanged).to.be.true
+
+        expect(xhr.status).to.eq(404)
+      })
+    })
+
+    // NOTE: flaky about 50% of the time in Firefox...
+    // temporarily skipping for now, but this needs
+    // to be reenabled after launch once we have time
+    // to look at the underlying failure cause
+    it.skip('allows multiple readystatechange calls', () => {
+      let responseStatuses = 0
+
+      cy
+      .server()
+      .route({ url: /longtext.txt/ }).as('getLongText')
+      .task('create:long:file')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest()
+
+        xhr.onreadystatechange = function () {
+          if (xhr.readyState === 3) {
+            return responseStatuses++
+          }
+        }
+
+        xhr.open('GET', `/_test-output/longtext.txt?${Cypress._.random(0, 1e6)}`)
+        xhr.send()
+
+        return null
+      })
+      .wait('@getLongText').then((xhr) => {
+        expect(responseStatuses).to.be.gt(1)
+
+        expect(xhr.status).to.eq(200)
+      })
+    })
+
+    // https://github.com/cypress-io/cypress/issues/5864
+    it('does not exceed max call stack', () => {
+      cy
       .server()
-      .route({url: /foo/}).as("getFoo")
-      .window().then(function(win) {
-        const xhr = new win.XMLHttpRequest();
-        xhr.open("GET", "/foo");
+      .route({ url: /foo/ }).as('getFoo')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest()
+
+        xhr.open('GET', '/foo')
 
         // This tests an old bug where calling onreadystatechange's getter would
         // create nested wrapper functions and exceed the max stack depth when called.
         // 20000 nested calls should be enough to break the stack in most implementations
-        xhr.onreadystatechange = () => ({});
-        [__range__(1, 20000, false).map((i) => xhr.onreadystatechange())];
+        xhr.onreadystatechange = () => {
+          return {}
+        }
 
-        xhr.send();
-        return null;}).wait("@getFoo").then(xhr => expect(xhr.status).to.eq(404)));
+        for (let i = 0; i < 20000; i++) {
+          xhr.onreadystatechange()
+        }
 
-    it("works with jquery too", function() {
-      let failed = false;
-      let onloaded = false;
+        xhr.send()
 
-      return cy
-        .server()
-        .route({url: /foo/}).as("getFoo")
-        .window().then(function(win) {
-          const handlers = ["onload", "onerror", "onreadystatechange"];
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(xhr.status).to.eq(404)
+      })
+    })
 
-          const wrap = function() {
-            const xhr = this;
+    it('works with jquery too', () => {
+      let failed = false
+      let onloaded = false
 
-            return handlers.forEach(function(handler) {
-              const bak = xhr[handler];
+      cy
+      .server()
+      .route({ url: /foo/ }).as('getFoo')
+      .window().then((win) => {
+        const handlers = ['onload', 'onerror', 'onreadystatechange']
 
-              return xhr[handler] = function() {
-                if (_.isFunction(bak)) {
-                  return bak.apply(xhr, arguments);
-                }
-              };
-            });
-          };
+        const wrap = function () {
+          const xhr = this
 
-          const {
-            open
-          } = win.XMLHttpRequest.prototype;
+          handlers.forEach((handler) => {
+            const bak = xhr[handler]
 
-          win.XMLHttpRequest.prototype.open = function() {
-            this.addEventListener("readystatechange", wrap, false);
+            xhr[handler] = (...args) => {
+              if (_.isFunction(bak)) {
+                bak.apply(xhr, args)
+              }
+            }
+          })
+        }
 
-            return open.apply(this, arguments);
-          };
+        const { open } = win.XMLHttpRequest.prototype
 
-          const xhr = win.$.get("/foo")
-          .fail(() => failed = true).always(() => onloaded = true);
+        win.XMLHttpRequest.prototype.open = function (...args) {
+          this.addEventListener('readystatechange', wrap, false)
 
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(failed).to.be.true;
-          expect(onloaded).to.be.true;
-          return expect(xhr.status).to.eq(404);
-      });
-    });
+          open.apply(this, args)
+        }
 
-    it("calls existing onload handlers", function() {
-      let onloaded = false;
+        win.$.get('/foo')
+        .fail(() => {
+          failed = true
+        })
+        .always(() => {
+          onloaded = true
+        })
 
-      return cy
-        .server()
-        .route({url: /foo/}).as("getFoo")
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.onload = () => onloaded = true;
-          xhr.open("GET", "/foo");
-          xhr.send();
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(onloaded).to.be.true;
-          return expect(xhr.status).to.eq(404);
-      });
-    });
-
-    it("calls onload handlers attached after xhr#send", function() {
-      let onloaded = false;
-
-      return cy
-        .server()
-        .route({url: /foo/}).as("getFoo")
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.open("GET", "/foo");
-          xhr.send();
-          xhr.onload = () => onloaded = true;
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(onloaded).to.be.true;
-          return expect(xhr.status).to.eq(404);
-      });
-    });
-
-    it("calls onload handlers attached after xhr#send asynchronously", function() {
-      let onloaded = false;
-
-      return cy
-        .server()
-        .route({url: /timeout/}).as("getTimeout")
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.open("GET", "/timeout?ms=100");
-          xhr.send();
-          _.delay(() => xhr.onload = () => onloaded = true
-          , 20);
-          return null;}).wait("@getTimeout").then(function(xhr) {
-          expect(onloaded).to.be.true;
-          return expect(xhr.status).to.eq(200);
-      });
-    });
-
-    it("fallbacks even when onreadystatechange is overriden", function() {
-        let onloaded = false;
-        let onreadystatechanged = false;
-
-        return cy
-          .server()
-          .route({url: /timeout/}).as("get.timeout")
-          .window().then(function(win) {
-            const xhr = new win.XMLHttpRequest;
-            xhr.open("GET", "/timeout?ms=100");
-            xhr.send();
-            xhr.onreadystatechange = () => onreadystatechanged = true;
-            xhr.onload = () => onloaded = true;
-            return null;}).wait("@get.timeout").then(function(xhr) {
-            expect(onloaded).to.be.true;
-            expect(onreadystatechanged).to.be.true;
-            return expect(xhr.status).to.eq(200);
-        });
-    });
-
-    //# FIXME: I have no idea why this is skipped, this test is rly old
-    describe.skip("filtering requests", function() {
-      beforeEach(() => cy.server());
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(failed).to.be.true
+        expect(onloaded).to.be.true
+        expect(xhr.status).to.eq(404)
+      })
+    })
+
+    it('calls existing onload handlers', () => {
+      let onloaded = false
+
+      cy
+      .server()
+      .route({ url: /foo/ }).as('getFoo')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest
+
+        xhr.onload = () => {
+          onloaded = true
+        }
+
+        xhr.open('GET', '/foo')
+        xhr.send()
+
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(onloaded).to.be.true
+        expect(xhr.status).to.eq(404)
+      })
+    })
+
+    it('calls onload handlers attached after xhr#send', () => {
+      let onloaded = false
+
+      cy
+      .server()
+      .route({ url: /foo/ }).as('getFoo')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest
+
+        xhr.open('GET', '/foo')
+        xhr.send()
+        xhr.onload = () => {
+          return onloaded = true
+        }
+
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(onloaded).to.be.true
+        expect(xhr.status).to.eq(404)
+      })
+    })
+
+    it('calls onload handlers attached after xhr#send asynchronously', () => {
+      let onloaded = false
+
+      cy
+      .server()
+      .route({ url: /timeout/ }).as('getTimeout')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest
+
+        xhr.open('GET', '/timeout?ms=100')
+        xhr.send()
+        _.delay(() => {
+          xhr.onload = () => {
+            onloaded = true
+          }
+        }, 20)
+
+        return null
+      })
+      .wait('@getTimeout').then((xhr) => {
+        expect(onloaded).to.be.true
+        expect(xhr.status).to.eq(200)
+      })
+    })
+
+    it('fallbacks even when onreadystatechange is overriden', () => {
+      let onloaded = false
+      let onreadystatechanged = false
+
+      cy
+      .server()
+      .route({ url: /timeout/ }).as('get.timeout')
+      .window().then((win) => {
+        const xhr = new win.XMLHttpRequest
+
+        xhr.open('GET', '/timeout?ms=100')
+        xhr.send()
+        xhr.onreadystatechange = () => {
+          onreadystatechanged = true
+        }
+
+        xhr.onload = () => {
+          onloaded = true
+        }
+
+        return null
+      })
+      .wait('@get.timeout').then((xhr) => {
+        expect(onloaded).to.be.true
+        expect(onreadystatechanged).to.be.true
+        expect(xhr.status).to.eq(200)
+      })
+    })
+
+    // FIXME: I have no idea why this is skipped, this test is rly old
+    describe.skip('filtering requests', () => {
+      beforeEach(() => {
+        cy.server()
+      })
 
       const extensions = {
-        html: "ajax html",
-        js: "{foo: \"bar\"}",
-        css: "body {}"
-      };
-
-      _.each(extensions, (val, ext) => it(`filters out non ajax requests by default for extension: .${ext}`, done => cy.state("window").$.get(`/fixtures/app.${ext}`).done(function(res) {
-        expect(res).to.eq(val);
-        return done();
-      })));
-
-      return it("can disable default filtering", done => //# this should throw since it should return 404 when no
-      //# route matches it
-      cy.server({ignore: false}).window().then(w => Promise.resolve(w.$.get("/fixtures/app.html")).catch(() => done())));
-    });
-
-    describe("url rewriting", function() {
-      it("has a FQDN absolute-relative url", () => cy
+        html: 'ajax html',
+        js: '{foo: "bar"}',
+        css: 'body {}',
+      }
+
+      _.each(extensions, (val, ext) => {
+        it(`filters out non ajax requests by default for extension: .${ext}`, (done) => {
+          cy.state('window').$.get(`/fixtures/app.${ext}`).done((res) => {
+            expect(res).to.eq(val)
+
+            done()
+          })
+        })
+      })
+
+      it('can disable default filtering', (done) => {
+        // this should throw since it should return 404 when no
+        // route matches it
+        cy.server({ ignore: false }).window().then((w) => {
+          Promise.resolve(w.$.get('/fixtures/app.html')).catch(() => {
+            done()
+          })
+        })
+      })
+    })
+
+    describe('url rewriting', () => {
+      it('has a FQDN absolute-relative url', () => {
+        cy
         .server()
         .route({
-          url: /foo/
-        }).as("getFoo")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("/foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3500/foo");
-          return expect(this.open).to.be.calledWith("GET", "/foo");
-      }));
-
-      it("has a relative URL", () => cy
+          url: /foo/,
+        }).as('getFoo')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('/foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3500/foo')
+          expect(this.open).to.be.calledWith('GET', '/foo')
+        })
+      })
+
+      it('has a relative URL', () => {
+        cy
         .server()
-        .route(/foo/).as("getFoo")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3500/fixtures/foo");
-          return expect(this.open).to.be.calledWith("GET", "foo");
-      }));
-
-      it("resolves relative urls correctly when base tag is present", () => cy
+        .route(/foo/).as('getFoo')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3500/fixtures/foo')
+          expect(this.open).to.be.calledWith('GET', 'foo')
+        })
+      })
+
+      it('resolves relative urls correctly when base tag is present', () => {
+        cy
         .server()
         .route({
-          url: /foo/
-        }).as("getFoo")
-        .window().then(function(win) {
-          win.$("<base href='/'>").appendTo(win.$("head"));
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3500/foo");
-          return expect(this.open).to.be.calledWith("GET", "foo");
-      }));
-
-      it("resolves relative urls correctly when base tag is present on nested routes", () => cy
+          url: /foo/,
+        }).as('getFoo')
+        .window().then(function (win) {
+          win.$('<base href=\'/\'>').appendTo(win.$('head'))
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3500/foo')
+          expect(this.open).to.be.calledWith('GET', 'foo')
+        })
+      })
+
+      it('resolves relative urls correctly when base tag is present on nested routes', () => {
+        cy
         .server()
         .route({
-          url: /foo/
-        }).as("getFoo")
-        .window().then(function(win) {
-          win.$("<base href='/nested/route/path'>").appendTo(win.$("head"));
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("../foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3500/nested/foo");
-          return expect(this.open).to.be.calledWith("GET", "../foo");
-      }));
-
-      it("allows cross origin requests to go out as necessary", () => cy
+          url: /foo/,
+        }).as('getFoo')
+        .window().then(function (win) {
+          win.$('<base href=\'/nested/route/path\'>').appendTo(win.$('head'))
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('../foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3500/nested/foo')
+          expect(this.open).to.be.calledWith('GET', '../foo')
+        })
+      })
+
+      it('allows cross origin requests to go out as necessary', () => {
+        cy
         .server()
-        .route(/foo/).as("getFoo")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("http://localhost:3501/foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3501/foo");
-          return expect(this.open).to.be.calledWith("GET", "http://localhost:3501/foo");
-      }));
-
-      it("rewrites FQDN url's for stubs", () => cy
+        .route(/foo/).as('getFoo')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('http://localhost:3501/foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3501/foo')
+          expect(this.open).to.be.calledWith('GET', 'http://localhost:3501/foo')
+        })
+      })
+
+      it('rewrites FQDN url\'s for stubs', () => {
+        cy
         .server()
         .route({
           url: /foo/,
-          response: {}
-        }).as("getFoo")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("http://localhost:9999/foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:9999/foo");
-          return expect(this.open).to.be.calledWith("GET", "/__cypress/xhrs/http://localhost:9999/foo");
-      }));
-
-      it("rewrites absolute url's for stubs", () => cy
+          response: {},
+        }).as('getFoo')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('http://localhost:9999/foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:9999/foo')
+          expect(this.open).to.be.calledWith('GET', '/__cypress/xhrs/http://localhost:9999/foo')
+        })
+      })
+
+      it('rewrites absolute url\'s for stubs', () => {
+        cy
         .server()
-        .route(/foo/, {}).as("getFoo")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("/foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3500/foo");
-          return expect(this.open).to.be.calledWith("GET", "/__cypress/xhrs/http://localhost:3500/foo");
-      }));
-
-      it("rewrites 404's url's for stubs", () => cy
-        .server({force404: true})
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          return new Promise(resolve => win.$.ajax({
-            method: "POST",
-            url: "/foo",
-            data: JSON.stringify({foo: "bar"})
-          }).fail(() => resolve()));}).then(function() {
-          const {
-            xhr
-          } = cy.state("responses")[0];
-          expect(xhr.url).to.eq("http://localhost:3500/foo");
-          return expect(this.open).to.be.calledWith("POST", "/__cypress/xhrs/http://localhost:3500/foo");
-      }));
-
-      it("rewrites urls with nested segments", () => cy
+        .route(/foo/, {}).as('getFoo')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('/foo')
+
+          return null
+        }).wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3500/foo')
+          expect(this.open).to.be.calledWith('GET', '/__cypress/xhrs/http://localhost:3500/foo')
+        })
+      })
+
+      it('rewrites 404\'s url\'s for stubs', () => {
+        cy
+        .server({ force404: true })
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+
+          return new Promise((resolve) => {
+            win.$.ajax({
+              method: 'POST',
+              url: '/foo',
+              data: JSON.stringify({ foo: 'bar' }),
+            }).fail(() => {
+              resolve()
+            })
+          })
+        })
+        .then(function () {
+          const { xhr } = cy.state('responses')[0]
+
+          expect(xhr.url).to.eq('http://localhost:3500/foo')
+          expect(this.open).to.be.calledWith('POST', '/__cypress/xhrs/http://localhost:3500/foo')
+        })
+      })
+
+      it('rewrites urls with nested segments', () => {
+        cy
         .server()
         .route({
           url: /phones/,
-          response: {}
-        }).as("getPhones")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("phones/phones.json");
-          return null;}).wait("@getPhones")
-        .then(function() {
-          const {
-            xhr
-          } = cy.state("responses")[0];
-          expect(xhr.url).to.eq("http://localhost:3500/fixtures/phones/phones.json");
-          return expect(this.open).to.be.calledWith("GET", "/__cypress/xhrs/http://localhost:3500/fixtures/phones/phones.json");
-      }));
-
-      it("does not rewrite CORS", () => cy.window().then(function(win) {
-        this.open = cy.spy(cy.state("server").options, "onOpen");
-        return new Promise(resolve => win.$.get("http://www.google.com/phones/phones.json").fail(() => resolve()));}).then(function() {
-        const {
-          xhr
-        } = cy.state("requests")[0];
-        expect(xhr.url).to.eq("http://www.google.com/phones/phones.json");
-        return expect(this.open).to.be.calledWith("GET", "http://www.google.com/phones/phones.json");
-      }));
-
-      it("can stub real CORS requests too", () => cy
+          response: {},
+        })
+        .as('getPhones')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('phones/phones.json')
+
+          return null
+        })
+        .wait('@getPhones')
+        .then(function () {
+          const { xhr } = cy.state('responses')[0]
+
+          expect(xhr.url).to.eq('http://localhost:3500/fixtures/phones/phones.json')
+          expect(this.open).to.be.calledWith('GET', '/__cypress/xhrs/http://localhost:3500/fixtures/phones/phones.json')
+        })
+      })
+
+      it('does not rewrite CORS', () => {
+        cy.window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+
+          return new Promise((resolve) => {
+            win.$.get('http://www.google.com/phones/phones.json').fail(() => {
+              resolve()
+            })
+          })
+        })
+        .then(function () {
+          const { xhr } = cy.state('requests')[0]
+
+          expect(xhr.url).to.eq('http://www.google.com/phones/phones.json')
+          expect(this.open).to.be.calledWith('GET', 'http://www.google.com/phones/phones.json')
+        })
+      })
+
+      it('can stub real CORS requests too', () => {
+        cy
         .server()
         .route({
           url: /phones/,
-          response: {}
-        }).as("getPhones")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("http://www.google.com/phones/phones.json");
-          return null;}).wait("@getPhones")
-        .then(function() {
-          const {
-            xhr
-          } = cy.state("responses")[0];
-          expect(xhr.url).to.eq("http://www.google.com/phones/phones.json");
-          return expect(this.open).to.be.calledWith("GET", "/__cypress/xhrs/http://www.google.com/phones/phones.json");
-      }));
-
-      it("can stub CORS string routes", () => cy
+          response: {},
+        })
+        .as('getPhones')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('http://www.google.com/phones/phones.json')
+
+          return null
+        })
+        .wait('@getPhones')
+        .then(function () {
+          const { xhr } = cy.state('responses')[0]
+
+          expect(xhr.url).to.eq('http://www.google.com/phones/phones.json')
+          expect(this.open).to.be.calledWith('GET', '/__cypress/xhrs/http://www.google.com/phones/phones.json')
+        })
+      })
+
+      it('can stub CORS string routes', () => {
+        cy
         .server()
-        .route("http://localhost:3501/fixtures/app.json").as("getPhones")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("http://localhost:3501/fixtures/app.json");
-          return null;}).wait("@getPhones")
-        .then(function() {
-          const {
-            xhr
-          } = cy.state("responses")[0];
-          expect(xhr.url).to.eq("http://localhost:3501/fixtures/app.json");
-          return expect(this.open).to.be.calledWith("GET", "http://localhost:3501/fixtures/app.json");
-      }));
-
-      // it "can stub root requests to CORS", ->
-      //   cy
-      //     .server()
-      //     .route({
-      //       url: "http://localhost:3501"
-      //       stub: false
-      //     }).as("getPhones")
-      //     .window().then (win) ->
-      //       @open = cy.spy(cy.state("server").options, "onOpen")
-      //       win.$.get("http://localhost:3501")
-      //       null
-      //     .wait("@getPhones")
-      //     .then ->
-      //       xhr = cy.state("responses")[0].xhr
-      //       expect(xhr.url).to.eq("http://localhost:3501")
-      //       expect(@open).to.be.calledWith("GET", "/http://localhost:3501")
-
-      it("sets display correctly when there is no remoteOrigin", () => //# this is an example of having cypress act as your webserver
-      //# when the remoteHost is <root>
-      cy
+        .route('http://localhost:3501/fixtures/app.json').as('getPhones')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('http://localhost:3501/fixtures/app.json')
+
+          return null
+        })
+        .wait('@getPhones')
+        .then(function () {
+          const { xhr } = cy.state('responses')[0]
+
+          expect(xhr.url).to.eq('http://localhost:3501/fixtures/app.json')
+          expect(this.open).to.be.calledWith('GET', 'http://localhost:3501/fixtures/app.json')
+        })
+      })
+
+      it('sets display correctly when there is no remoteOrigin', () => {
+        // this is an example of having cypress act as your webserver
+        // when the remoteHost is <root>
+        cy
         .server()
         .route({
           url: /foo/,
-          response: {}
-        }).as("getFoo")
-        .window().then(function(win) {
-          //# trick cypress into thinking the remoteOrigin is location:9999
-          cy.stub(cy, "getRemoteLocation").withArgs("origin").returns("");
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("/foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.url).to.eq("http://localhost:3500/foo");
-          return expect(this.open).to.be.calledWith("GET", "/__cypress/xhrs/http://localhost:3500/foo");
-      }));
-
-      it("decodes proxy urls", () => cy
+          response: {},
+        })
+        .as('getFoo')
+        .window().then(function (win) {
+          // trick cypress into thinking the remoteOrigin is location:9999
+          cy.stub(cy, 'getRemoteLocation').withArgs('origin').returns('')
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('/foo')
+
+          return null
+        })
+        .wait('@getFoo').then(function (xhr) {
+          expect(xhr.url).to.eq('http://localhost:3500/foo')
+          expect(this.open).to.be.calledWith('GET', '/__cypress/xhrs/http://localhost:3500/foo')
+        })
+      })
+
+      it('decodes proxy urls', () => {
+        cy
         .server()
         .route({
           url: /users/,
-          response: {}
-        }).as("getUsers")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("/users?q=(id eq 123)");
-          return null;}).wait("@getUsers")
-        .then(function() {
-          const {
-            xhr
-          } = cy.state("responses")[0];
-          expect(xhr.url).to.eq("http://localhost:3500/users?q=(id eq 123)");
-          const url = encodeURI("users?q=(id eq 123)");
-          return expect(this.open).to.be.calledWith("GET", `/__cypress/xhrs/http://localhost:3500/${url}`);
-      }));
-
-      return it("decodes proxy urls #2", () => cy
+          response: {},
+        })
+        .as('getUsers')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('/users?q=(id eq 123)')
+
+          return null
+        })
+        .wait('@getUsers')
+        .then(function () {
+          const { xhr } = cy.state('responses')[0]
+
+          expect(xhr.url).to.eq('http://localhost:3500/users?q=(id eq 123)')
+
+          const url = encodeURI('users?q=(id eq 123)')
+
+          expect(this.open).to.be.calledWith('GET', `/__cypress/xhrs/http://localhost:3500/${url}`)
+        })
+      })
+
+      it('decodes proxy urls #2', () => {
+        cy
         .server()
-        .route(/accounts/, {}).as("getAccounts")
-        .window().then(function(win) {
-          this.open = cy.spy(cy.state("server").options, "onOpen");
-          win.$.get("/accounts?page=1&%24filter=(rowStatus+eq+1)&%24orderby=name+asc&includeOpenFoldersCount=true&includeStatusCount=true");
-          return null;}).wait("@getAccounts")
-        .then(function() {
-          const {
-            xhr
-          } = cy.state("responses")[0];
-          expect(xhr.url).to.eq("http://localhost:3500/accounts?page=1&$filter=(rowStatus+eq+1)&$orderby=name+asc&includeOpenFoldersCount=true&includeStatusCount=true");
-          const url = "accounts?page=1&%24filter=(rowStatus+eq+1)&%24orderby=name+asc&includeOpenFoldersCount=true&includeStatusCount=true";
-          return expect(this.open).to.be.calledWith("GET", `/__cypress/xhrs/http://localhost:3500/${url}`);
-      }));
-    });
-
-    describe("#onResponse", () => it("calls onResponse callback with cy context + proxy xhr", function(done) {
-      return cy
+        .route(/accounts/, {}).as('getAccounts')
+        .window().then(function (win) {
+          this.open = cy.spy(cy.state('server').options, 'onOpen')
+          win.$.get('/accounts?page=1&%24filter=(rowStatus+eq+1)&%24orderby=name+asc&includeOpenFoldersCount=true&includeStatusCount=true')
+
+          return null
+        })
+        .wait('@getAccounts')
+        .then(function () {
+          const { xhr } = cy.state('responses')[0]
+
+          expect(xhr.url).to.eq('http://localhost:3500/accounts?page=1&$filter=(rowStatus+eq+1)&$orderby=name+asc&includeOpenFoldersCount=true&includeStatusCount=true')
+
+          const url = 'accounts?page=1&%24filter=(rowStatus+eq+1)&%24orderby=name+asc&includeOpenFoldersCount=true&includeStatusCount=true'
+
+          expect(this.open).to.be.calledWith('GET', `/__cypress/xhrs/http://localhost:3500/${url}`)
+        })
+      })
+    })
+
+    describe('#onResponse', () => {
+      it('calls onResponse callback with cy context + proxy xhr', (done) => {
+        cy
         .server()
         .route({
           url: /foo/,
-          response: {foo: "bar"},
-          onResponse(xhr) {
-            expect(this).to.eq(cy);
-            expect(xhr.responseBody).to.deep.eq({foo: "bar"});
-            return done();
-          }
+          response: { foo: 'bar' },
+          onResponse (xhr) {
+            expect(this).to.eq(cy)
+            expect(xhr.responseBody).to.deep.eq({ foo: 'bar' })
+
+            done()
+          },
+        })
+        .window().then((win) => {
+          win.$.get('/foo')
+
+          return null
         })
-        .window().then(function(win) {
-          win.$.get("/foo");
-          return null;
-      });
-    }));
+      })
+    })
 
-    describe("#onAbort", () => it("calls onAbort callback with cy context + proxy xhr", function(done) {
-      return cy
+    describe('#onAbort', () => {
+      it('calls onAbort callback with cy context + proxy xhr', (done) => {
+        cy
         .server()
         .route({
           url: /foo/,
           response: {},
-          onAbort(xhr) {
-            expect(this).to.eq(cy);
-            expect(xhr.aborted).to.be.true;
-            return done();
-          }
+          onAbort (xhr) {
+            expect(this).to.eq(cy)
+            expect(xhr.aborted).to.be.true
+
+            done()
+          },
         })
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.open("GET", "/foo");
-          xhr.send();
-          xhr.abort();
-          return null;
-      });
-    }));
-
-    describe("request parsing", function() {
-      it("adds parses requestBody into JSON", function(done) {
-        return cy
-          .server()
-          .route({
-            method: "POST",
-            url: /foo/,
-            response: {},
-            onRequest(xhr) {
-              expect(this).to.eq(cy);
-              expect(xhr.requestBody).to.deep.eq({foo: "bar"});
-              return done();
-            }
+        .window().then((win) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('GET', '/foo')
+          xhr.send()
+          xhr.abort()
+
+          return null
+        })
+      })
+    })
+
+    describe('request parsing', () => {
+      it('adds parses requestBody into JSON', (done) => {
+        cy
+        .server()
+        .route({
+          method: 'POST',
+          url: /foo/,
+          response: {},
+          onRequest (xhr) {
+            expect(this).to.eq(cy)
+            expect(xhr.requestBody).to.deep.eq({ foo: 'bar' })
+
+            done()
+          },
+        })
+        .window().then((win) => {
+          win.$.ajax({
+            type: 'POST',
+            url: '/foo',
+            data: JSON.stringify({ foo: 'bar' }),
+            dataType: 'json',
           })
-          .window().then(function(win) {
-            win.$.ajax({
-              type: "POST",
-              url: "/foo",
-              data: JSON.stringify({foo: "bar"}),
-              dataType: "json"
-            });
-            return null;
-        });
-      });
-
-      //# https://github.com/cypress-io/cypress/issues/65
-      it("provides the correct requestBody on multiple requests", function() {
-        const post = function(win, obj) {
+
+          return null
+        })
+      })
+
+      // https://github.com/cypress-io/cypress/issues/65
+      it('provides the correct requestBody on multiple requests', () => {
+        const post = function (win, obj) {
           win.$.ajax({
-            type: "POST",
-            url: "/foo",
+            type: 'POST',
+            url: '/foo',
             data: JSON.stringify(obj),
-            dataType: "json"
-          });
+            dataType: 'json',
+          })
+
+          return null
+        }
+
+        cy
+        .server()
+        .route('POST', /foo/, {}).as('getFoo')
+        .window().then((win) => {
+          return post(win, { foo: 'bar1' })
+        })
+        .wait('@getFoo').its('requestBody').should('deep.eq', { foo: 'bar1' })
+        .window().then((win) => {
+          return post(win, { foo: 'bar2' })
+        })
+        .wait('@getFoo').its('requestBody').should('deep.eq', { foo: 'bar2' })
+      })
+
+      it('handles arraybuffer', () => {
+        cy
+        .server()
+        .route('GET', /buffer/).as('getBuffer')
+        .window().then((win) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.responseType = 'arraybuffer'
+          xhr.open('GET', '/buffer')
+          xhr.send()
+
+          return null
+        })
+        .wait('@getBuffer').then((xhr) => {
+          expect(xhr.responseBody.toString()).to.eq('[object ArrayBuffer]')
+        })
+      })
+
+      it('handles xml', () => {
+        cy
+        .server()
+        .route('GET', /xml/).as('getXML')
+        .window().then((win) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('GET', '/xml')
+          xhr.send()
+
+          return null
+        })
+        .wait('@getXML').its('responseBody').should('eq', '<foo>bar</foo>')
+      })
+    })
+
+    describe('issue #84', () => {
+      it('does not incorrectly match options', () => {
+        cy
+        .server()
+        .route({
+          method: 'GET',
+          url: /answers/,
+          status: 503,
+          response: {},
+        })
+        .route(/forms/, []).as('getForm')
+        .window().then((win) => {
+          win.$.getJSON('/forms')
+
+          return null
+        })
+        .wait('@getForm').its('status').should('eq', 200)
+      })
+    })
+
+    describe('#issue #85', () => {
+      it('correctly returns the right XHR alias', () => {
+        cy
+        .server()
+        .route({
+          method: 'POST',
+          url: /foo/,
+          response: {},
+        })
+        .as('getFoo')
+        .route(/folders/, { foo: 'bar' }).as('getFolders')
+        .window().then((win) => {
+          win.$.getJSON('/folders')
+          win.$.post('/foo', {})
+
+          return null
+        })
+        .wait('@getFolders')
+        .wait('@getFoo')
+        .route(/folders/, { foo: 'baz' }).as('getFoldersWithSearch')
+        .window().then((win) => {
+          win.$.getJSON('/folders/123/activities?foo=bar')
+
+          return null
+        })
+        .wait('@getFoldersWithSearch').its('url')
+        .should('contain', '?foo=bar')
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'xhr') {
+            this.lastLog = log
+            this.logs.push(log)
+          }
+        })
+
+        return null
+      })
+
+      context('requests', () => {
+        it('immediately logs xhr obj', () => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .window().then((win) => {
+            win.$.get('foo')
+
+            return null
+          }).then(function () {
+            const { lastLog } = this
+
+            expect(lastLog.pick('name', 'displayName', 'event', 'alias', 'aliasType', 'state')).to.deep.eq({
+              name: 'xhr',
+              displayName: 'xhr stub',
+              event: true,
+              alias: 'getFoo',
+              aliasType: 'route',
+              state: 'pending',
+            })
+
+            const snapshots = lastLog.get('snapshots')
+
+            expect(snapshots.length).to.eq(1)
+            expect(snapshots[0].name).to.eq('request')
+            expect(snapshots[0].body).to.be.an('object')
+          })
+        })
+
+        it('does not end xhr requests when the associated command ends', () => {
+          let logs = null
+
+          cy
+          .server()
+          .route({
+            url: /foo/,
+            response: {},
+            delay: 50,
+          }).as('getFoo')
+          .window().then((w) => {
+            w.$.getJSON('foo')
+            w.$.getJSON('foo')
+            w.$.getJSON('foo')
+
+            return null
+          })
+          .then(() => {
+            const cmd = cy.queue.find({ name: 'window' })
+
+            logs = cmd.get('next').get('logs')
+
+            expect(logs.length).to.eq(3)
+
+            _.each(logs, (log) => {
+              expect(log.get('name')).to.eq('xhr')
+              expect(log.get('end')).not.to.be.true
+            })
+          }).wait(['@getFoo', '@getFoo', '@getFoo']).then(() => {
+            _.each(logs, (log) => {
+              expect(log.get('name')).to.eq('xhr')
+              expect(log.get('ended')).to.be.true
+            })
+          })
+        })
+
+        it('updates log immediately whenever an xhr is aborted', () => {
+          let xhrs = null
+
+          cy
+          .server()
+          .route({
+            url: /foo/,
+            response: {},
+            delay: 50,
+          }).as('getFoo')
+          .window().then((win) => {
+            const xhr1 = win.$.getJSON('foo1')
+
+            win.$.getJSON('foo2')
+
+            xhr1.abort()
+
+            return null
+          }).then(() => {
+            xhrs = cy.queue.logs({ name: 'xhr' })
+
+            expect(xhrs[0].get('state')).to.eq('failed')
+            expect(xhrs[0].get('error').name).to.eq('AbortError')
+            expect(xhrs[0].get('snapshots').length).to.eq(2)
+            expect(xhrs[0].get('snapshots')[0].name).to.eq('request')
+            expect(xhrs[0].get('snapshots')[0].body).to.be.a('object')
+            expect(xhrs[0].get('snapshots')[1].name).to.eq('aborted')
+            expect(xhrs[0].get('snapshots')[1].body).to.be.a('object')
+
+            expect(cy.state('requests').length).to.eq(2)
+
+            // the abort should have set its response
+            expect(cy.state('responses').length).to.eq(1)
+          })
+          .wait(['@getFoo', '@getFoo']).then(() => {
+            // should not re-snapshot after the response
+            expect(xhrs[0].get('snapshots').length).to.eq(2)
+          })
+        })
+
+        it('can access requestHeaders', () => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .window().then((win) => {
+            win.$.ajax({
+              method: 'GET',
+              url: '/foo',
+              headers: {
+                'x-token': '123',
+              },
+            })
+
+            return null
+          })
+          .wait('@getFoo').its('requestHeaders').should('have.property', 'x-token', '123')
+        })
+      })
+
+      context('responses', () => {
+        beforeEach(() => {
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .window().then((win) => {
+            win.$.get('foo_bar')
+
+            return null
+          })
+          .wait('@getFoo')
+        })
+
+        it('logs obj', function () {
+          const obj = {
+            name: 'xhr',
+            displayName: 'xhr stub',
+            event: true,
+            message: '',
+            type: 'parent',
+            aliasType: 'route',
+            referencesAlias: undefined,
+            alias: 'getFoo',
+          }
+
+          const { lastLog } = this
+
+          _.each(obj, (value, key) => {
+            expect(lastLog.get(key)).to.deep.eq(value, `expected key: ${key} to eq value: ${value}`)
+          })
+        })
+
+        it('ends', function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('state')).to.eq('passed')
+        })
+
+        it('snapshots again', function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('snapshots').length).to.eq(2)
+          expect(lastLog.get('snapshots')[0].name).to.eq('request')
+          expect(lastLog.get('snapshots')[0].body).to.be.an('object')
+          expect(lastLog.get('snapshots')[1].name).to.eq('response')
+          expect(lastLog.get('snapshots')[1].body).to.be.an('object')
+        })
+      })
+    })
+
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 200)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.name === 'xhr') {
+            this.lastLog = log
+            this.logs.push(log)
+          }
+        })
+
+        return null
+      })
+
+      it('sets err on log when caused by code errors', function (done) {
+        const uncaughtException = cy.stub().returns(true)
+
+        cy.on('uncaught:exception', uncaughtException)
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('name')).to.eq('xhr')
+          expect(lastLog.get('error').message).contain('foo is not defined')
+          // since this is AUT code, we should allow error to be caught in 'uncaught:exception' hook
+          // https://github.com/cypress-io/cypress/issues/987
+          expect(uncaughtException).calledOnce
+
+          done()
+        })
+
+        cy.window().then((win) => {
+          return new Promise(() => {
+            win.$.get('http://www.google.com/foo.json')
+            .fail(() => {
+              foo.bar() // eslint-disable-line no-undef
+            })
+          })
+        })
+      })
+
+      it('causes errors caused by onreadystatechange callback function', function (done) {
+        const e = new Error('onreadystatechange caused this error')
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('name')).to.eq('xhr')
+          expect(err).to.eq(lastLog.get('error'))
+          expect(err).to.eq(e)
+
+          done()
+        })
+
+        cy
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            const xhr = new win.XMLHttpRequest
+
+            xhr.open('GET', '/foo')
+            xhr.onreadystatechange = function () {
+              throw e
+            }
+
+            xhr.send()
+          })
+        })
+      })
+    })
+  })
+
+  context('#server', () => {
+    it('sets serverIsStubbed', () => {
+      cy.server().then(() => {
+        expect(cy.state('serverIsStubbed')).to.be.true
+      })
+    })
+
+    it('can disable serverIsStubbed', () => {
+      cy.server({ enable: false }).then(() => {
+        expect(cy.state('serverIsStubbed')).to.be.false
+      })
+    })
+
+    it('sends enable to server', () => {
+      const set = cy.spy(cy.state('server'), 'set')
+
+      cy.server().then(() => {
+        expect(set).to.be.calledWithExactly({ enable: true })
+      })
+    })
+
+    it('can disable the server after enabling it', () => {
+      const set = cy.spy(cy.state('server'), 'set')
+
+      cy
+      .server()
+      .route(/app/, {}).as('getJSON')
+      .window().then((win) => {
+        win.$.get('/fixtures/app.json')
+
+        return null
+      })
+      .wait('@getJSON').its('responseBody').should('deep.eq', {})
+      .server({ enable: false })
+      .then(() => {
+        expect(set).to.be.calledWithExactly({ enable: false })
+      })
+      .window().then((win) => {
+        win.$.get('/fixtures/app.json')
+
+        return null
+      })
+      .wait('@getJSON').its('responseBody').should('not.deep.eq', {})
+    })
+
+    it('sets delay at 0 by default', () => {
+      cy
+      .server()
+      .route('*', {})
+      .then(() => {
+        expect(cy.state('server').getRoutes()[0].delay).to.eq(0)
+      })
+    })
+
+    it('passes down options.delay to routes', () => {
+      cy
+      .server({ delay: 100 })
+      .route('*', {})
+      .then(() => {
+        expect(cy.state('server').getRoutes()[0].delay).to.eq(100)
+      })
+    })
+
+    it('passes event argument to xhr.onreadystatechange', (done) => {
+      cy.window().then((win) => {
+        const xhr = new win.XMLHttpRequest()
+
+        xhr.onreadystatechange = function (e) {
+          expect(e).to.be.an.instanceof(win.Event)
+
+          done()
+        }
+
+        xhr.open('GET', 'http://localhost:3500/')
+      })
+    })
+
+    describe('errors', () => {
+      context('argument signature', () => {
+        _.each(['asdf', 123, null, undefined], (arg) => {
+          it(`throws on bad argument: ${arg}`, (done) => {
+            cy.on('fail', (err) => {
+              expect(err.message).to.include('`cy.server()` accepts only an object literal as its argument')
+              expect(err.docsUrl).to.eq('https://on.cypress.io/server')
+
+              done()
+            })
+
+            cy.server(arg)
+          })
+        })
+      })
+
+      it('after turning off server it throws attempting to route', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('`cy.route()` cannot be invoked before starting the `cy.server()`')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/server')
+
+          done()
+        })
+
+        cy.server()
+        cy.route(/app/, {})
+        cy.server({ enable: false })
+
+        cy.route(/app/, {})
+      })
+
+      describe('.log', () => {
+        beforeEach(function () {
+          this.logs = []
+
+          cy.on('log:added', (attrs, log) => {
+            if (attrs.name === 'xhr') {
+              this.lastLog = log
+              this.logs.push(log)
+            }
+          })
+
+          return null
+        })
+
+        it('provides specific #onFail', function (done) {
+          cy.on('fail', (err) => {
+            const obj = {
+              name: 'xhr',
+              referencesAlias: undefined,
+              alias: 'getFoo',
+              aliasType: 'route',
+              type: 'parent',
+              error: err,
+              instrument: 'command',
+              message: '',
+              event: true,
+            }
+
+            const { lastLog } = this
+
+            _.each(obj, (value, key) => {
+              expect(value).deep.eq(lastLog.get(key), `expected key: ${key} to eq value: ${value}`)
+            })
+
+            done()
+          })
+
+          cy
+          .server()
+          .route(/foo/, {}).as('getFoo')
+          .window().then((win) => {
+            return win.$.get('/foo').done(() => {
+              throw new Error('specific ajax error')
+            })
+          })
+        })
+      })
+    })
+  })
+
+  // FIXME: I have no idea why this is skipped, this test is rly old
+  context.skip('#server', () => {
+    beforeEach(function () {
+      const defaults = {
+        ignore: true,
+        respond: true,
+        delay: 10,
+        beforeRequest () {},
+        afterResponse () {},
+        onAbort () {},
+        onError () {},
+        onFilter () {},
+      }
+
+      this.options = (obj) => {
+        return _.extend(obj, defaults)
+      }
+
+      this.create = cy.spy(this.Cypress.Server, 'create')
+    })
+
+    it('can accept an onRequest and onResponse callback', function (done) {
+      const onRequest = () => {}
+      const onResponse = () => {}
+
+      cy.on('end', () => {
+        expect(this.create.getCall(0).args[1]).to.have.keys(_.keys(this.options({ onRequest, onResponse })))
+
+        done()
+      })
+
+      cy.server(onRequest, onResponse)
+    })
+
+    it('can accept onRequest and onRespond through options', function (done) {
+      const onRequest = () => {}
+      const onResponse = () => {}
+
+      cy.on('end', () => {
+        expect(this.create.getCall(0).args[1]).to.have.keys(_.keys(this.options({ onRequest, onResponse })))
+
+        done()
+      })
+
+      cy.server({ onRequest, onResponse })
+    })
+
+    describe('without sinon present', () => {
+      beforeEach(() => {
+        // force us to start from blank window
+        cy.state('$autIframe').prop('src', 'about:blank')
+      })
+
+      it('can start server with no errors', () => {
+        cy
+        .server()
+        .visit('http://localhost:3500/fixtures/sinon.html')
+      })
+
+      it('can add routes with no errors', () => {
+        cy
+        .server()
+        .route(/foo/, {})
+        .visit('http://localhost:3500/fixtures/sinon.html')
+      })
+
+      it('routes xhr requests', () => {
+        cy
+        .server()
+        .route(/foo/, { foo: 'bar' })
+        .visit('http://localhost:3500/fixtures/sinon.html')
+        .window().then((w) => {
+          return w.$.get('/foo')
+        })
+        .then((resp) => {
+          expect(resp).to.deep.eq({ foo: 'bar' })
+        })
+      })
+
+      it('works with aliases', () => {
+        cy
+        .server()
+        .route(/foo/, { foo: 'bar' }).as('getFoo')
+        .visit('http://localhost:3500/fixtures/sinon.html')
+        .window().then((w) => {
+          return w.$.get('/foo')
+        })
+        .wait('@getFoo').then((xhr) => {
+          expect(xhr.responseText).to.eq(JSON.stringify({ foo: 'bar' }))
+        })
+      })
+
+      it('prevents XHR\'s from going out from sinon.html', () => {
+        cy
+        .server()
+        .route(/bar/, { bar: 'baz' }).as('getBar')
+        .visit('http://localhost:3500/fixtures/sinon.html')
+        .wait('@getBar').then((xhr) => {
+          expect(xhr.responseText).to.eq(JSON.stringify({ bar: 'baz' }))
+        })
+      })
+    })
+  })
+
+  context('#route', () => {
+    beforeEach(function () {
+      this.expectOptionsToBe = (opts) => {
+        const options = this.route.getCall(0).args[0]
+
+        _.each(opts, (value, key) => {
+          expect(options[key]).to.deep.eq(opts[key], `failed on property: (${key})`)
+        })
+      }
+
+      cy.server().then(function () {
+        this.route = cy.spy(cy.state('server'), 'route')
+      })
+    })
+
+    it('accepts url, response', () => {
+      cy.route('/foo', {}).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: '/foo',
+          response: {},
+        })
+      })
+    })
+
+    it('accepts regex url, response', () => {
+      cy.route(/foo/, {}).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: /foo/,
+          response: {},
+        })
+      })
+    })
+
+    it('does not mutate other routes when using shorthand', () => {
+      cy
+      .route('POST', /foo/, {}).as('getFoo')
+      .route(/bar/, {}).as('getBar')
+      .then(function () {
+        expect(this.route.firstCall.args[0].method).to.eq('POST')
+        expect(this.route.secondCall.args[0].method).to.eq('GET')
+      })
+    })
+
+    it('accepts url, response, onRequest', () => {
+      const onRequest = () => {}
+
+      cy.route({
+        url: '/foo',
+        response: {},
+        onRequest,
+      }).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: '/foo',
+          response: {},
+          onRequest,
+          onResponse: undefined,
+        })
+      })
+    })
+
+    it('accepts url, response, onRequest, onResponse', () => {
+      const onRequest = () => {}
+      const onResponse = () => {}
+
+      cy.route({
+        url: '/foo',
+        response: {},
+        onRequest,
+        onResponse,
+      }).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: '/foo',
+          response: {},
+          onRequest,
+          onResponse,
+        })
+      })
+    })
+
+    it('accepts method, url, response', () => {
+      cy.route('GET', '/foo', {}).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: '/foo',
+          response: {},
+        })
+      })
+    })
+
+    it('accepts method, url, response, onRequest', () => {
+      const onRequest = () => {}
+
+      cy.route({
+        method: 'GET',
+        url: '/foo',
+        response: {},
+        onRequest,
+      }).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          url: '/foo',
+          status: 200,
+          response: {},
+          onRequest,
+          onResponse: undefined,
+        })
+      })
+    })
+
+    it('accepts method, url, response, onRequest, onResponse', () => {
+      const onRequest = () => {}
+      const onResponse = () => {}
+
+      cy.route({
+        method: 'GET',
+        url: '/foo',
+        response: {},
+        onRequest,
+        onResponse,
+      }).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          url: '/foo',
+          status: 200,
+          response: {},
+          onRequest,
+          onResponse,
+        })
+      })
+    })
+
+    it('uppercases method', () => {
+      cy.route('get', '/foo', {}).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: '/foo',
+          response: {},
+        })
+      })
+    })
+
+    it('accepts string or regex as the url', () => {
+      cy.route('get', /.*/, {}).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: /.*/,
+          response: {},
+        })
+      })
+    })
+
+    it('does not require response or method when not stubbing', () => {
+      cy
+      .server()
+      .route(/users/).as('getUsers')
+      .then(function () {
+        this.expectOptionsToBe({
+          status: 200,
+          method: 'GET',
+          url: /users/,
+        })
+      })
+    })
+
+    it('does not require response when not stubbing', () => {
+      cy
+      .server()
+      .route('POST', /users/).as('createUsers')
+      .then(function () {
+        this.expectOptionsToBe({
+          status: 200,
+          method: 'POST',
+          url: /users/,
+        })
+      })
+    })
+
+    it('accepts an object literal as options', () => {
+      const onRequest = () => {}
+      const onResponse = () => {}
+
+      const opts = {
+        method: 'PUT',
+        url: '/foo',
+        status: 200,
+        response: {},
+        onRequest,
+        onResponse,
+      }
+
+      cy.route(opts).then(function () {
+        this.expectOptionsToBe(opts)
+      })
+    })
+
+    it('can accept wildcard * as URL and converts to /.*/ regex', () => {
+      const opts = {
+        url: '*',
+        response: {},
+      }
+
+      cy.route(opts).then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: /.*/,
+          originalUrl: '*',
+          response: {},
+        })
+      })
+    })
+
+    // FIXME: I have no idea why this is skipped, this test is rly old
+    it.skip('can explicitly done() in onRequest function from options', (done) => {
+      cy
+      .server()
+      .route({
+        method: 'POST',
+        url: '/users',
+        response: {},
+        onRequest () {
+          done()
+        },
+      })
+      .then(() => {
+        cy.state('window').$.post('/users', 'name=brian')
+      })
+    })
+
+    it('can accept response as a function', () => {
+      const users = [{}, {}]
+      const getUsers = () => {
+        return users
+      }
+
+      cy.route(/users/, getUsers)
+      .then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: /users/,
+          response: users,
+        })
+      })
+    })
+
+    it('invokes response function with runnable.ctx', function () {
+      const ctx = this
+
+      const getUsers = function () {
+        expect(this === ctx).to.be.true
+      }
+
+      cy.route(/users/, getUsers)
+    })
+
+    it('passes options as argument', function () {
+      const getUsers = function (opts) {
+        expect(opts).to.be.an('object')
+        expect(opts.method).to.eq('GET')
+      }
+
+      cy.route(/users/, getUsers)
+    })
+
+    it('can accept response as a function which returns a promise', () => {
+      const users = [{}, {}]
+
+      const getUsers = () => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve(users)
+          }, 10)
+        })
+      }
+
+      cy.route(/users/, getUsers)
+      .then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 200,
+          url: /users/,
+          response: users,
+        })
+      })
+    })
+
+    it('can accept a function which returns options', () => {
+      const users = [{}, {}]
+
+      const getRoute = () => {
+        return {
+          method: 'GET',
+          url: /users/,
+          status: 201,
+          response () {
+            return Promise.resolve(users)
+          },
+        }
+      }
+
+      cy.route(getRoute)
+      .then(function () {
+        this.expectOptionsToBe({
+          method: 'GET',
+          status: 201,
+          url: /users/,
+          response: users,
+        })
+      })
+    })
+
+    it('invokes route function with runnable.ctx', function () {
+      const ctx = this
+
+      const getUsers = function () {
+        expect(this === ctx).to.be.true
+
+        return {
+          url: /foo/,
+        }
+      }
+
+      cy.route(getUsers)
+    })
+
+    // FIXME: I have no idea why this is skipped, this test is rly old
+    it.skip('adds multiple routes to the responses array', () => {
+      cy
+      .route('foo', {})
+      .route('bar', {})
+      .then(() => {
+        expect(cy.state('sandbox').server.responses).to.have.length(2)
+      })
+    })
+
+    it('can use regular strings as response', () => {
+      cy
+      .route('/foo', 'foo bar baz').as('getFoo')
+      .window().then((win) => {
+        win.$.get('/foo')
+
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(xhr.responseBody).to.eq('foo bar baz')
+      })
+    })
+
+    it('can stub requests with uncommon HTTP methods', () => {
+      cy
+      .route('PROPFIND', '/foo', 'foo bar baz').as('getFoo')
+      .window().then((win) => {
+        win.$.ajax({
+          url: '/foo',
+          method: 'PROPFIND',
+        })
+
+        return null
+      })
+      .wait('@getFoo').then((xhr) => {
+        expect(xhr.responseBody).to.eq('foo bar baz')
+      })
+    })
+
+    // https://github.com/cypress-io/cypress/issues/2372
+    it('warns if a percent-encoded URL is used', () => {
+      cy.spy(Cypress.utils, 'warning')
+
+      cy.route('GET', '/foo%25bar')
+      .then(() => {
+        expect(Cypress.utils.warning).to.be.calledWith(stripIndent`\
+          A \`url\` with percent-encoded characters was passed to \`cy.route()\`, but \`cy.route()\` expects a decoded \`url\`.
+
+          Did you mean to pass "/foo%bar"?
+
+          https://on.cypress.io/route`)
+      })
+    })
+
+    it('does not warn if an invalid percent-encoded URL is used', () => {
+      cy.spy(Cypress.utils, 'warning')
+
+      cy.route('GET', 'http://example.com/%E0%A4%A')
+      .then(() => {
+        expect(Cypress.utils.warning).to.not.be.called
+      })
+    })
+
+    // FIXME: I have no idea why this is skipped, this test is rly old
+    it.skip('does not error when response is null but respond is false', () => {
+      cy.route({
+        url: /foo/,
+        respond: false,
+      })
+    })
+
+    describe('deprecations', () => {
+      beforeEach(function () {
+        this.warn = cy.spy(window.top.console, 'warn')
+      })
+
+      it('logs on {force404: false}', () => {
+        cy.server({ force404: false })
+        .then(function () {
+          expect(this.warn).to.be.calledWith('Cypress Warning: Passing `cy.server({force404: false})` is now the default behavior of `cy.server()`. You can safely remove this option.')
+        })
+      })
+
+      it('does not log on {force404: true}', () => {
+        cy.server({ force404: true })
+        .then(function () {
+          expect(this.warn).not.to.be.called
+        })
+      })
+
+      it('logs on {stub: false}', () => {
+        cy.server({ stub: false })
+        .then(function () {
+          expect(this.warn).to.be.calledWithMatch('Cypress Warning: Passing `cy.server({stub: false})` is now deprecated. You can safely remove: `{stub: false}`.\n\nhttps://on.cypress.io/deprecated-stub-false-on-server')
+        })
+      })
+    })
+
+    describe('request response alias', () => {
+      it('matches xhrs with lowercase methods', () => {
+        cy
+        .route(/foo/, {}).as('getFoo')
+        .window().then((win) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('get', '/foo')
+          xhr.send()
+        }).wait('@getFoo')
+      })
+
+      it('can pass an alias reference to route', () => {
+        cy
+        .noop({ foo: 'bar' }).as('foo')
+        .route(/foo/, '@foo').as('getFoo')
+        .window().then((win) => {
+          win.$.getJSON('foo')
+
+          return null
+        })
+        .wait('@getFoo').then(function (xhr) {
+          expect(xhr.responseBody).to.deep.eq({ foo: 'bar' })
+          expect(xhr.responseBody).to.deep.eq(this.foo)
+        })
+      })
+
+      it('can pass an alias when using a response function', () => {
+        const getFoo = () => {
+          return Promise.resolve('@foo')
+        }
+
+        cy
+        .noop({ foo: 'bar' }).as('foo')
+        .route(/foo/, getFoo).as('getFoo')
+        .window().then((win) => {
+          win.$.getJSON('foo')
+
+          return null
+        })
+        .wait('@getFoo').then(function (xhr) {
+          expect(xhr.responseBody).to.deep.eq({ foo: 'bar' })
+          expect(xhr.responseBody).to.deep.eq(this.foo)
+        })
+      })
+
+      it('can alias a route without stubbing it', () => {
+        cy
+        .route(/fixtures\/app/).as('getFoo')
+        .window().then((win) => {
+          win.$.get('/fixtures/app.json')
+
+          return null
+        })
+        .wait('@getFoo').then((xhr) => {
+          const log = cy.queue.logs({ name: 'xhr' })[0]
+
+          expect(log.get('displayName')).to.eq('xhr')
+          expect(log.get('alias')).to.eq('getFoo')
+          expect(xhr.responseBody).to.deep.eq({
+            some: 'json',
+            foo: {
+              bar: 'baz',
+            },
+          })
+        })
+      })
+    })
+
+    describe('response fixtures', () => {
+      it('works if the JSON file has an object', () => {
+        cy
+        .server()
+        .route({
+          method: 'POST',
+          url: '/test-xhr',
+          response: 'fixture:valid.json',
+        })
+        .visit('/fixtures/xhr-triggered.html')
+        .get('#trigger-xhr')
+        .click()
+
+        cy.contains('#result', '{"foo":1,"bar":{"baz":"cypress"}}').should('be.visible')
+      })
+
+      it('works if the JSON file has null content', () => {
+        cy
+        .server()
+        .route({
+          method: 'POST',
+          url: '/test-xhr',
+          response: 'fixture:null.json',
+        })
+        .visit('/fixtures/xhr-triggered.html')
+        .get('#trigger-xhr')
+        .click()
+
+        cy.contains('#result', '""').should('be.visible')
+      })
+    })
+
+    describe('errors', () => {
+      beforeEach(function () {
+        Cypress.config('defaultCommandTimeout', 100)
+
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          this.lastLog = log
+          this.logs.push(log)
+        })
+
+        return null
+      })
+
+      it('throws if cy.server() hasnt been invoked', (done) => {
+        cy.state('serverIsStubbed', false)
+
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.route()` cannot be invoked before starting the `cy.server()`')
+
+          done()
+        })
+
+        cy.route()
+      })
+
+      it('url must be a string or regexp', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.route()` was called with an invalid `url`. `url` must be either a string or regular expression.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/route')
+
+          done()
+        })
+
+        cy.route({
+          url: {},
+        })
+      })
+
+      it('url must be a string or regexp when a function', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.route()` was called with an invalid `url`. `url` must be either a string or regular expression.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/route')
+
+          done()
+        })
+
+        const getUrl = () => {
+          return Promise.resolve({ url: {} })
+        }
+
+        cy.route(getUrl)
+      })
+
+      it('fails when functions reject', (done) => {
+        const error = new Error
+
+        cy.on('fail', (err) => {
+          expect(err).to.eq(error)
+
+          done()
+        })
+
+        const getUrl = () => {
+          return Promise.reject(error)
+        }
+
+        cy.route(getUrl)
+      })
+
+      it('fails when method is invalid', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.route()` was called with an invalid method: `POSTS`.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/route')
+
+          done()
+        })
+
+        cy.route('posts', '/foo', {})
+      })
+
+      it('requires a url when given a response', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.route()` must be called with a `url`. It can be a string or regular expression.')
+
+          done()
+        })
+
+        cy.route({})
+      })
+
+      _.each([null, undefined], (val) => {
+        it(`throws if response options was explicitly set to ${val}`, (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.route()` cannot accept an `undefined` or `null` response. It must be set to something, even an empty string will work.')
+            expect(err.docsUrl).to.eq('https://on.cypress.io/route')
+
+            done()
+          })
+
+          cy.route({ url: /foo/, response: val })
+        })
+
+        it(`throws if response argument was explicitly set to ${val}`, (done) => {
+          cy.on('fail', (err) => {
+            expect(err.message).to.include('`cy.route()` cannot accept an `undefined` or `null` response. It must be set to something, even an empty string will work.')
+
+            done()
+          })
+
+          cy.route(/foo/, val)
+        })
+      })
+
+      it('requires arguments', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.include('`cy.route()` was not provided any arguments. You must provide valid arguments.')
+          expect(err.docsUrl).to.eq('https://on.cypress.io/route')
+
+          done()
+        })
+
+        cy.route()
+      })
+
+      it('sets err on log when caused by the XHR response', function (done) {
+        this.route.restore()
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          // route + window + xhr log === 3
+          expect(this.logs.length).to.eq(3)
+          expect(lastLog.get('name')).to.eq('xhr')
+          expect(err).to.eq(lastLog.get('error'))
+
+          done()
+        })
+
+        cy
+        .route(/foo/, {}).as('getFoo')
+        .window().then((win) => {
+          return win.$.get('foo_bar').done(() => {
+            foo.bar() // eslint-disable-line no-undef
+          })
+        })
+      })
+
+      // FIXME: I have no idea why this is skipped, this test is rly old
+      it.skip('explodes if response fixture signature errors', function (done) {
+        this.trigger = cy.stub(this.Cypress, 'trigger').withArgs('fixture').callsArgWithAsync(2, { __error: 'some error' })
+
+        const logs = []
+
+        const _this = this
+
+        // we have to restore the trigger when commandErr is called
+        // so that something logs out!
+        cy.commandErr = _.wrap(cy.commandErr, function (orig, err) {
+          _this.Cypress.trigger.restore()
+          orig.call(this, err)
+        })
+
+        cy.on('log:added', (attrs, log) => {
+          this.log = log
+          logs.push(this.log)
+        })
+
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(err.message).to.eq('some error')
+          expect(this.logs.length).to.eq(1)
+          expect(lastLog.get('name')).to.eq('route')
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('message')).to.eq('/foo/, fixture:bar')
+
+          done()
+        })
+
+        cy.route(/foo/, 'fixture:bar')
+      })
+
+      // TODO: handle this uncaught exception failure
+      it.skip('does not retry (cancels existing promise) when xhr errors', (done) => {
+        const cancel = cy.spy(Promise.prototype, 'cancel')
+
+        cy.on('command:retry', () => {
+          if (cy.state('error')) {
+            done('should have canceled and not retried after failing')
+          }
+        })
+
+        cy.on('fail', (err) => {
+          const p = cy.state('promise')
+
+          _.delay(() => {
+            expect(cancel).to.be.calledOn(p)
+
+            done()
+          }, 100)
+        })
+
+        cy
+        .route({
+          url: /foo/,
+          response: {},
+          delay: 100,
+        })
+        .window().then((win) => {
+          win.$.getJSON('/foo').done(() => {
+            throw new Error('foo failed')
+          })
+
+          return null
+        })
+        .get('button').should('have.class', 'does-not-exist')
+      })
+
+      it('explodes if response alias cannot be found', function (done) {
+        cy.on('fail', (err) => {
+          const { lastLog } = this
+
+          expect(this.logs.length).to.eq(2)
+          expect(err.message).to.eq('`cy.route()` could not find a registered alias for: `@bar`.\nAvailable aliases are: `foo`.')
+          expect(lastLog.get('name')).to.eq('route')
+          expect(lastLog.get('error')).to.eq(err)
+          expect(lastLog.get('message')).to.eq('/foo/, @bar')
+
+          done()
+        })
+
+        cy
+        .wrap({ foo: 'bar' }).as('foo')
+        .route(/foo/, '@bar')
+      })
+    })
+
+    describe('.log', () => {
+      beforeEach(function () {
+        this.logs = []
+
+        cy.on('log:added', (attrs, log) => {
+          if (attrs.instrument === 'route') {
+            this.lastLog = log
+            this.logs.push(log)
+          }
+        })
+
+        return null
+      })
+
+      it('has name of route', () => {
+        cy.route('/foo', {}).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('name')).to.eq('route')
+        })
+      })
+
+      it('uses the wildcard URL', () => {
+        cy.route('*', {}).then(function () {
+          const { lastLog } = this
+
+          expect(lastLog.get('url')).to.eq('*')
+        })
+      })
+
+      it('#consoleProps', () => {
+        cy.route('*', { foo: 'bar' }).as('foo').then(function () {
+          expect(this.lastLog.invoke('consoleProps')).to.deep.eq({
+            Command: 'route',
+            Method: 'GET',
+            URL: '*',
+            Status: 200,
+            Response: { foo: 'bar' },
+            Alias: 'foo',
+            // Responded: 1 time
+            // "-------": ""
+            // Responses: []
+          })
+        })
+      })
+
+      describe('numResponses', () => {
+        it('is initially 0', function () {
+          cy.route(/foo/, {}).then(() => {
+            const { lastLog } = this
+
+            expect(lastLog.get('numResponses')).to.eq(0)
+          })
+        })
+
+        it('is incremented to 2', () => {
+          cy
+          .route(/foo/, {})
+          .window().then((win) => {
+            return win.$.get('/foo')
+          })
+          .then(function () {
+            expect(this.lastLog.get('numResponses')).to.eq(1)
+          })
+        })
+
+        it('is incremented for each matching request', () => {
+          cy
+          .route(/foo/, {})
+          .window().then((win) => {
+            return Promise.all([
+              win.$.get('/foo'),
+              win.$.get('/foo'),
+              win.$.get('/foo'),
+            ])
+          })
+          .then(function () {
+            expect(this.lastLog.get('numResponses')).to.eq(3)
+          })
+        })
+      })
+    })
+  })
+
+  context('consoleProps logs', () => {
+    beforeEach(function () {
+      this.logs = []
+
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'xhr') {
+          this.lastLog = log
+          this.logs.push(log)
+        }
+      })
+
+      return null
+    })
+
+    describe('when stubbed', () => {
+      it('says Stubbed: Yes', () => {
+        cy
+        .server()
+        .route(/foo/, {}).as('getFoo')
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            return win.$.get('/foo').done(resolve)
+          })
+        })
+        .then(function () {
+          expect(this.lastLog.invoke('consoleProps').Stubbed).to.eq('Yes')
+        })
+      })
+    })
+
+    describe('zero configuration / zero routes', () => {
+      beforeEach(() => {
+        cy
+        .server({ force404: true })
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            win.$.ajax({
+              method: 'POST',
+              url: '/foo',
+              data: JSON.stringify({ foo: 'bar' }),
+            }).fail(() => {
+              resolve()
+            })
+          })
+        })
+      })
+
+      it('calculates duration', () => {
+        cy.then(function () {
+          const consoleProps = this.lastLog.invoke('consoleProps')
+
+          expect(consoleProps.Duration).to.be.a('number')
+          expect(consoleProps.Duration).to.be.gt(1)
+          expect(consoleProps.Duration).to.be.lt(1000)
+        })
+      })
 
-          return null;
-        };
+      it('sends back regular 404', () => {
+        cy.then(function () {
+          const { xhr } = cy.state('responses')[0]
 
-        return cy
-          .server()
-          .route("POST", /foo/, {}).as("getFoo")
-          .window().then(win => post(win, {foo: "bar1"})).wait("@getFoo").its("requestBody").should("deep.eq", {foo: "bar1"})
-          .window().then(win => post(win, {foo: "bar2"})).wait("@getFoo").its("requestBody").should("deep.eq", {foo: "bar2"});
-      });
+          const consoleProps = _.pick(this.lastLog.invoke('consoleProps'), 'Method', 'Status', 'URL', 'XHR')
 
-      it("handles arraybuffer", () => cy
-        .server()
-        .route("GET", /buffer/).as("getBuffer")
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.responseType = "arraybuffer";
-          xhr.open("GET", "/buffer");
-          xhr.send();
-          return null;}).wait("@getBuffer").then(xhr => expect(xhr.responseBody.toString()).to.eq("[object ArrayBuffer]")));
-
-      return it("handles xml", () => cy
+          expect(consoleProps).to.deep.eq({
+            Method: 'POST',
+            Status: '404 (Not Found)',
+            URL: 'http://localhost:3500/foo',
+            XHR: xhr.xhr,
+          })
+        })
+      })
+
+      it('says Stubbed: Yes when sent 404 back', function () {
+        expect(this.lastLog.invoke('consoleProps').Stubbed).to.eq('Yes')
+      })
+    })
+
+    describe('whitelisting', () => {
+      it('does not send back 404s on whitelisted routes', () => {
+        cy
         .server()
-        .route("GET", /xml/).as("getXML")
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.open("GET", "/xml");
-          xhr.send();
-          return null;}).wait("@getXML").its("responseBody").should("eq", "<foo>bar</foo>"));
-    });
-
-    describe("issue #84", () => it("does not incorrectly match options", () => cy
-      .server()
-      .route({
-        method: "GET",
-        url: /answers/,
-        status: 503,
-        response: {}
+        .window().then((win) => {
+          return win.$.get('/fixtures/app.js')
+        })
+        .then((resp) => {
+          expect(resp).to.eq('{ \'bar\' }\n')
+        })
       })
-    .route(/forms/, []).as("getForm")
-    .window().then(function(win) {
-      win.$.getJSON("/forms");
-      return null;}).wait("@getForm").its("status").should("eq", 200)));
+    })
 
-    describe("#issue #85", () => it("correctly returns the right XHR alias", () => cy
-      .server()
-      .route({
-        method: "POST",
-        url: /foo/,
-        response: {}
-      }).as("getFoo")
-      .route(/folders/, {foo: "bar"}).as("getFolders")
-      .window().then(function(win) {
-        win.$.getJSON("/folders");
-        win.$.post("/foo", {});
-        return null;}).wait("@getFolders")
-      .wait("@getFoo")
-      .route(/folders/, {foo: "baz"}).as("getFoldersWithSearch")
-      .window().then(function(win) {
-        win.$.getJSON("/folders/123/activities?foo=bar");
-        return null;}).wait("@getFoldersWithSearch").its("url")
-      .should("contain", "?foo=bar")));
-
-    describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "xhr") {
-            this.lastLog = log;
-            return this.logs.push(log);
-          }
-        });
+    describe('route setup', () => {
+      beforeEach(() => {
+        cy
+        .server({ force404: true })
+        .route('/foo', {}).as('anyRequest')
+        .window().then((win) => {
+          win.$.get('/bar')
 
-        return null;
-      });
+          return null
+        })
+      })
 
-      context("requests", function() {
-        it("immediately logs xhr obj", () => cy
-          .server()
-          .route(/foo/, {}).as("getFoo")
-          .window().then(function(win) {
-            win.$.get("foo");
-            return null;}).then(function() {
-            const {
-              lastLog
-            } = this;
-
-            expect(lastLog.pick("name", "displayName", "event", "alias", "aliasType", "state")).to.deep.eq({
-              name: "xhr",
-              displayName: "xhr stub",
-              event: true,
-              alias: "getFoo",
-              aliasType: "route",
-              state: "pending"
-            });
-
-            const snapshots = lastLog.get("snapshots");
-            expect(snapshots.length).to.eq(1);
-            expect(snapshots[0].name).to.eq("request");
-            return expect(snapshots[0].body).to.be.an("object");
-        }));
-
-        it("does not end xhr requests when the associated command ends", function() {
-          let logs = null;
-
-          return cy
-            .server()
-            .route({
-              url: /foo/,
-              response: {},
-              delay: 50
-            }).as("getFoo")
-            .window().then(function(w) {
-              w.$.getJSON("foo");
-              w.$.getJSON("foo");
-              w.$.getJSON("foo");
-              return null;}).then(function() {
-              const cmd = cy.queue.find({name: "window"});
-              logs = cmd.get("next").get("logs");
-
-              expect(logs.length).to.eq(3);
-
-              return _.each(logs, function(log) {
-                expect(log.get("name")).to.eq("xhr");
-                return expect(log.get("end")).not.to.be.true;
-              });}).wait(["@getFoo", "@getFoo", "@getFoo"]).then(() => _.each(logs, function(log) {
-            expect(log.get("name")).to.eq("xhr");
-            return expect(log.get("ended")).to.be.true;
-          }));
-        });
-
-        it("updates log immediately whenever an xhr is aborted", function() {
-          const snapshot = null;
-          let xhrs = null;
-
-          return cy
-            .server()
-            .route({
-              url: /foo/,
-              response: {},
-              delay: 50
-            }).as("getFoo")
-            .window().then(function(win) {
-              const xhr1 = win.$.getJSON("foo1");
-              const xhr2 = win.$.getJSON("foo2");
-              xhr1.abort();
-
-              return null;}).then(function() {
-              xhrs = cy.queue.logs({name: "xhr"});
-
-              expect(xhrs[0].get("state")).to.eq("failed");
-              expect(xhrs[0].get("error").name).to.eq("AbortError");
-              expect(xhrs[0].get("snapshots").length).to.eq(2);
-              expect(xhrs[0].get("snapshots")[0].name).to.eq("request");
-              expect(xhrs[0].get("snapshots")[0].body).to.be.a("object");
-              expect(xhrs[0].get("snapshots")[1].name).to.eq("aborted");
-              expect(xhrs[0].get("snapshots")[1].body).to.be.a("object");
-
-              expect(cy.state("requests").length).to.eq(2);
-
-              //# the abort should have set its response
-              return expect(cy.state("responses").length).to.eq(1);}).wait(["@getFoo", "@getFoo"]).then(() => //# should not re-snapshot after the response
-          expect(xhrs[0].get("snapshots").length).to.eq(2));
-        });
-
-        return it("can access requestHeaders", () => cy
-          .server()
-          .route(/foo/, {}).as("getFoo")
-          .window().then(function(win) {
-            win.$.ajax({
-              method: "GET",
-              url: "/foo",
-              headers: {
-                "x-token": "123"
-              }
-            });
-            return null;}).wait("@getFoo").its("requestHeaders").should("have.property", "x-token", "123"));
-      });
+      it('sends back 404 when request doesnt match route', () => {
+        cy.then(function () {
+          const consoleProps = this.lastLog.invoke('consoleProps')
 
-      return context("responses", function() {
-        beforeEach(() => cy
-          .server()
-          .route(/foo/, {}).as("getFoo")
-          .window().then(function(win) {
-            win.$.get("foo_bar");
-            return null;}).wait("@getFoo"));
+          expect(consoleProps.Note).to.eq('This request did not match any of your routes. It was automatically sent back \'404\'. Setting cy.server({force404: false}) will turn off this behavior.')
+        })
+      })
+    })
 
-        it("logs obj", function() {
-          const obj = {
-            name: "xhr",
-            displayName: "xhr stub",
-            event: true,
-            message: "",
-            type: "parent",
-            aliasType: "route",
-            referencesAlias: undefined,
-            alias: "getFoo"
-          };
-
-          const {
-            lastLog
-          } = this;
-
-          return _.each(obj, (value, key) => {
-            return expect(lastLog.get(key)).to.deep.eq(value, `expected key: ${key} to eq value: ${value}`);
-          });
-        });
-
-        it("ends", function() {
-          const {
-            lastLog
-          } = this;
-
-          return expect(lastLog.get("state")).to.eq("passed");
-        });
-
-        return it("snapshots again", function() {
-          const {
-            lastLog
-          } = this;
-
-          expect(lastLog.get("snapshots").length).to.eq(2);
-          expect(lastLog.get("snapshots")[0].name).to.eq("request");
-          expect(lastLog.get("snapshots")[0].body).to.be.an("object");
-          expect(lastLog.get("snapshots")[1].name).to.eq("response");
-          return expect(lastLog.get("snapshots")[1].body).to.be.an("object");
-        });
-      });
-    });
-
-    return describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 200);
-
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.name === "xhr") {
-            this.lastLog = log;
-            return this.logs.push(log);
-          }
-        });
-
-        return null;
-      });
-
-      it("sets err on log when caused by code errors", function(done) {
-        const finalThenCalled = false;
-        const uncaughtException = cy.stub().returns(true);
-        cy.on('uncaught:exception', uncaughtException);
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("name")).to.eq("xhr");
-          expect(lastLog.get("error").message).contain('foo is not defined');
-          //# since this is AUT code, we should allow error to be caught in 'uncaught:exception' hook
-          //# https://github.com/cypress-io/cypress/issues/987
-          expect(uncaughtException).calledOnce;
-          return done();
-        });
-
-        return cy.window().then(win => new Promise(resolve => win.$.get("http://www.google.com/foo.json")
-        .fail(() => foo.bar())));
-      });
-
-      return it("causes errors caused by onreadystatechange callback function", function(done) {
-        const e = new Error("onreadystatechange caused this error");
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("name")).to.eq("xhr");
-          expect(err).to.eq(lastLog.get("error"));
-          expect(err).to.eq(e);
-          return done();
-        });
-
-        return cy
-          .window().then(win => new Promise(function(resolve) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.open("GET", "/foo");
-          xhr.onreadystatechange = function() {
-            throw e;
-          };
-          return xhr.send();
-        }));
-      });
-    });
-  });
-
-  context("#server", function() {
-    it("sets serverIsStubbed", () => cy.server().then(() => expect(cy.state("serverIsStubbed")).to.be.true));
-
-    it("can disable serverIsStubbed", () => cy.server({enable: false}).then(() => expect(cy.state("serverIsStubbed")).to.be.false));
-
-    it("sends enable to server", function() {
-      const set = cy.spy(cy.state("server"), "set");
-
-      return cy.server().then(() => expect(set).to.be.calledWithExactly({enable: true}));
-    });
-
-    it("can disable the server after enabling it", function() {
-      const set = cy.spy(cy.state("server"), "set");
-
-      return cy
+    describe('{force404: false}', () => {
+      beforeEach(() => {
+        cy
         .server()
-        .route(/app/, {}).as("getJSON")
-        .window().then(function(win) {
-          win.$.get("/fixtures/app.json");
-          return null;}).wait("@getJSON").its("responseBody").should("deep.eq", {})
-        .server({enable: false})
-        .then(() => expect(set).to.be.calledWithExactly({enable: false})).window().then(function(win) {
-          win.$.get("/fixtures/app.json");
-          return null;}).wait("@getJSON").its("responseBody").should("not.deep.eq", {});
-    });
-
-    it("sets delay at 0 by default", () => cy
-      .server()
-      .route("*", {})
-      .then(() => expect(cy.state("server").getRoutes()[0].delay).to.eq(0)));
-
-    it("passes down options.delay to routes", () => cy
-      .server({delay: 100})
-      .route("*", {})
-      .then(() => expect(cy.state("server").getRoutes()[0].delay).to.eq(100)));
-
-    it("passes event argument to xhr.onreadystatechange", done => cy.window().then(function(win) {
-      const xhr = new win.XMLHttpRequest();
-      xhr.onreadystatechange = function(e) {
-        expect(e).to.be.an.instanceof(win.Event);
-        return done();
-      };
-      return xhr.open("GET", "http://localhost:3500/");
-    }));
-
-    return describe("errors", function() {
-      context("argument signature", () => _.each(["asdf", 123, null, undefined], arg => it(`throws on bad argument: ${arg}`, function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.server()` accepts only an object literal as its argument");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/server");
-          return done();
-        });
-
-        return cy.server(arg);
-      })));
-
-      it("after turning off server it throws attempting to route", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.eq("`cy.route()` cannot be invoked before starting the `cy.server()`");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/server");
-          return done();
-        });
-
-        cy.server();
-        cy.route(/app/, {});
-        cy.server({enable: false});
-        return cy.route(/app/, {});
-      });
-
-      return describe(".log", function() {
-        beforeEach(function() {
-          this.logs = [];
-
-          cy.on("log:added", (attrs, log) => {
-            if (attrs.name === "xhr") {
-              this.lastLog = log;
-              return this.logs.push(log);
-            }
-          });
+        .window().then((win) => {
+          return win.$.getJSON('/fixtures/app.json')
+        })
+      })
 
-          return null;
-        });
+      it('says Stubbed: No when request isnt forced 404', function () {
+        expect(this.lastLog.invoke('consoleProps').Stubbed).to.eq('No')
+      })
 
-        return it("provides specific #onFail", function(done) {
-          cy.on("fail", err => {
-            const obj = {
-              name: "xhr",
-              referencesAlias: undefined,
-              alias: "getFoo",
-              aliasType: "route",
-              type: "parent",
-              error: err,
-              instrument: "command",
-              message: "",
-              event: true
-            };
+      it('logs request + response headers', () => {
+        cy.then(function () {
+          const consoleProps = this.lastLog.invoke('consoleProps')
 
-            const {
-              lastLog
-            } = this;
+          expect(consoleProps.Request.headers).to.be.an('object')
+          expect(consoleProps.Response.headers).to.be.an('object')
+        })
+      })
 
-            _.each(obj, (value, key) => {
-              return expect(value).deep.eq(lastLog.get(key), `expected key: ${key} to eq value: ${value}`);
-            });
-
-            return done();
-          });
-
-          return cy
-            .server()
-            .route(/foo/, {}).as("getFoo")
-            .window().then(win => win.$.get("/foo").done(function() {
-            throw new Error("specific ajax error");
-          }));
-        });
-      });
-    });
-  });
-
-  //# FIXME: I have no idea why this is skipped, this test is rly old
-  context.skip("#server", function() {
-    beforeEach(function() {
-      const defaults = {
-        ignore: true,
-        respond: true,
-        delay: 10,
-        beforeRequest() {},
-        afterResponse() {},
-        onAbort() {},
-        onError() {},
-        onFilter() {}
-      };
+      it('logs Method, Status, URL, and XHR', () => {
+        cy.then(function () {
+          const { xhr } = cy.state('responses')[0]
 
-      this.options = obj => _.extend(obj, defaults);
+          const consoleProps = _.pick(this.lastLog.invoke('consoleProps'), 'Method', 'Status', 'URL', 'XHR')
 
-      return this.create = cy.spy(this.Cypress.Server, "create");
-    });
+          expect(consoleProps).to.deep.eq({
+            Method: 'GET',
+            URL: 'http://localhost:3500/fixtures/app.json',
+            Status: '200 (OK)',
+            XHR: xhr.xhr,
+          })
+        })
+      })
 
-    it("can accept an onRequest and onResponse callback", function(done) {
-      const onRequest = function() {};
-      const onResponse = function() {};
+      it('logs response', () => {
+        cy.then(function () {
+          const consoleProps = this.lastLog.invoke('consoleProps')
 
-      cy.on("end", () => {
-        expect(this.create.getCall(0).args[1]).to.have.keys(_.keys(this.options({onRequest, onResponse, onResponse})));
-        return done();
-      });
+          expect(consoleProps.Response.body).to.deep.eq({
+            some: 'json',
+            foo: {
+              bar: 'baz',
+            },
+          })
+        })
+      })
 
-      return cy.server(onRequest, onResponse);
-    });
+      it('sets groups Initiator', () => {
+        cy.then(function () {
+          const consoleProps = this.lastLog.invoke('consoleProps')
 
-    it("can accept onRequest and onRespond through options", function(done) {
-      const onRequest = function() {};
-      const onResponse = function() {};
+          const group = consoleProps.groups()[0]
 
-      cy.on("end", () => {
-        expect(this.create.getCall(0).args[1]).to.have.keys(_.keys(this.options({onRequest, onResponse, onResponse})));
-        return done();
-      });
+          expect(group.name).to.eq('Initiator')
+          expect(group.label).to.be.false
+          expect(group.items[0]).to.be.a('string')
+          expect(group.items[0].split('\n').length).to.gt(1)
+        })
+      })
+    })
+  })
 
-      return cy.server({onRequest, onResponse});
-    });
+  context('renderProps', () => {
+    beforeEach(function () {
+      this.logs = []
 
-    return describe("without sinon present", function() {
-      beforeEach(() => //# force us to start from blank window
-      cy.state("$autIframe").prop("src", "about:blank"));
+      cy.on('log:added', (attrs, log) => {
+        if (attrs.name === 'xhr') {
+          this.lastLog = log
+          this.logs.push(log)
+        }
+      })
 
-      it("can start server with no errors", () => cy
-        .server()
-        .visit("http://localhost:3500/fixtures/sinon.html"));
+      return null
+    })
 
-      it("can add routes with no errors", () => cy
+    describe('in any case', () => {
+      beforeEach(() => {
+        cy
         .server()
         .route(/foo/, {})
-        .visit("http://localhost:3500/fixtures/sinon.html"));
-
-      it("routes xhr requests", () => cy
-        .server()
-        .route(/foo/, {foo: "bar"})
-        .visit("http://localhost:3500/fixtures/sinon.html")
-        .window().then(w => w.$.get("/foo")).then(resp => expect(resp).to.deep.eq({foo: "bar"})));
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            return win.$.get('/foo').done(resolve)
+          })
+        })
+      })
 
-      it("works with aliases", () => cy
-        .server()
-        .route(/foo/, {foo: "bar"}).as("getFoo")
-        .visit("http://localhost:3500/fixtures/sinon.html")
-        .window().then(w => w.$.get("/foo")).wait("@getFoo").then(xhr => expect(xhr.responseText).to.eq(JSON.stringify({foo: "bar"}))));
+      it('sends correct message', () => {
+        cy.then(function () {
+          expect(this.lastLog.invoke('renderProps').message).to.equal('GET 200 /foo')
+        })
+      })
+    })
 
-      return it("prevents XHR's from going out from sinon.html", () => cy
+    describe('when response is successful', () => {
+      beforeEach(() => {
+        cy
         .server()
-        .route(/bar/, {bar: "baz"}).as("getBar")
-        .visit("http://localhost:3500/fixtures/sinon.html")
-        .wait("@getBar").then(xhr => expect(xhr.responseText).to.eq(JSON.stringify({bar: "baz"}))));
-    });
-  });
-
-  context("#route", function() {
-    beforeEach(function() {
-      this.expectOptionsToBe = opts => {
-        const options = this.route.getCall(0).args[0];
-        return _.each(opts, (value, key) => expect(options[key]).to.deep.eq(opts[key], `failed on property: (${key})`));
-      };
-
-      return cy.server().then(function() {
-        return this.route = cy.spy(cy.state("server"), "route");
-      });
-    });
-
-    it("accepts url, response", () => cy.route("/foo", {}).then(function() {
-      return this.expectOptionsToBe({
-        method: "GET",
-        status: 200,
-        url: "/foo",
-        response: {}
-      });
-    }));
-
-    it("accepts regex url, response", () => cy.route(/foo/, {}).then(function() {
-      return this.expectOptionsToBe({
-        method: "GET",
-        status: 200,
-        url: /foo/,
-        response: {}
-      });
-    }));
-
-    it("does not mutate other routes when using shorthand", () => cy
-      .route("POST", /foo/, {}).as("getFoo")
-      .route(/bar/, {}).as("getBar")
-      .then(function() {
-        expect(this.route.firstCall.args[0].method).to.eq("POST");
-        return expect(this.route.secondCall.args[0].method).to.eq("GET");
-    }));
-
-    it("accepts url, response, onRequest", function() {
-      const onRequest = function() {};
-
-      return cy.route({
-        url: "/foo",
-        response: {},
-        onRequest
-      }).then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          status: 200,
-          url: "/foo",
-          response: {},
-          onRequest,
-          onResponse: undefined
-        });
-      });
-    });
+        .route(/foo/, {})
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            return win.$.get('/foo').done(resolve)
+          })
+        })
+      })
 
-    it("accepts url, response, onRequest, onResponse", function() {
-      const onRequest = function() {};
-      const onResponse = function() {};
+      it('sends correct indicator', () => {
+        cy.then(function () {
+          expect(this.lastLog.invoke('renderProps').indicator).to.equal('successful')
+        })
+      })
+    })
 
-      return cy.route({
-        url: "/foo",
-        response: {},
-        onRequest,
-        onResponse
-      }).then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          status: 200,
-          url: "/foo",
-          response: {},
-          onRequest,
-          onResponse
-        });
-      });
-    });
-
-    it("accepts method, url, response", () => cy.route("GET", "/foo", {}).then(function() {
-      return this.expectOptionsToBe({
-        method: "GET",
-        status: 200,
-        url: "/foo",
-        response: {}
-      });
-    }));
+    describe('when response is pending', () => {
+      beforeEach(() => {
+        cy
+        .server()
+        .route({ url: '/foo', delay: 500, response: {} })
+        .window().then((win) => {
+          win.$.get('/foo')
 
-    it("accepts method, url, response, onRequest", function() {
-      const onRequest = function() {};
+          return null
+        })
+      })
 
-      return cy.route({
-        method: "GET",
-        url: "/foo",
-        response: {},
-        onRequest
-      }).then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          url: "/foo",
-          status: 200,
-          response: {},
-          onRequest,
-          onResponse: undefined
-        });
-      });
-    });
-
-    it("accepts method, url, response, onRequest, onResponse", function() {
-      const onRequest = function() {};
-      const onResponse = function() {};
-
-      return cy.route({
-        method: "GET",
-        url: "/foo",
-        response: {},
-        onRequest,
-        onResponse
-      }).then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          url: "/foo",
-          status: 200,
-          response: {},
-          onRequest,
-          onResponse
-        });
-      });
-    });
-
-    it("uppercases method", () => cy.route("get", "/foo", {}).then(function() {
-      return this.expectOptionsToBe({
-        method: "GET",
-        status: 200,
-        url: "/foo",
-        response: {}
-      });
-    }));
-
-    it("accepts string or regex as the url", () => cy.route("get", /.*/, {}).then(function() {
-      return this.expectOptionsToBe({
-        method: "GET",
-        status: 200,
-        url: /.*/,
-        response: {}
-      });
-    }));
+      // FAILING
+      it('sends correct message', function () {
+        expect(this.lastLog.invoke('renderProps').message).to.equal('GET --- /foo')
+      })
 
-    it("does not require response or method when not stubbing", () => cy
-      .server()
-      .route(/users/).as("getUsers")
-      .then(function() {
-        return this.expectOptionsToBe({
-          status: 200,
-          method: "GET",
-          url: /users/
-        });
-    }));
+      it('sends correct indicator', function () {
+        expect(this.lastLog.invoke('renderProps').indicator).to.equal('pending')
+      })
+    })
 
-    it("does not require response when not stubbing", () => cy
-      .server()
-      .route("POST", /users/).as("createUsers")
-      .then(function() {
-        return this.expectOptionsToBe({
-          status: 200,
-          method: "POST",
-          url: /users/
-        });
-    }));
+    describe('when response is outside 200 range', () => {
+      beforeEach(() => {
+        cy
+        .server()
+        .route({ url: '/foo', status: 500, response: {} })
+        .window().then((win) => {
+          return new Promise((resolve) => {
+            return win.$.get('/foo').fail(() => {
+              resolve()
+            })
+          })
+        })
+      })
 
-    it("accepts an object literal as options", function() {
-      const onRequest = function() {};
-      const onResponse = function() {};
+      it('sends correct indicator', () => {
+        cy.then(function () {
+          expect(this.lastLog.invoke('renderProps').indicator).to.equal('bad')
+        })
+      })
+    })
+  })
 
-      const opts = {
-        method: "PUT",
-        url: "/foo",
-        status: 200,
-        response: {},
-        onRequest,
-        onResponse
-      };
+  context('abort', () => {
+    const xhrs = []
 
-      return cy.route(opts).then(function() {
-        return this.expectOptionsToBe(opts);
-      });
-    });
+    beforeEach(() => {
+      cy.visit('/fixtures/jquery.html')
+    })
 
-    it("can accept wildcard * as URL and converts to /.*/ regex", function() {
-      const opts = {
-        url: "*",
-        response: {}
-      };
+    it('does not abort xhr\'s between tests', () => {
+      cy.window().then((win) => {
+        _.times(2, () => {
+          const xhr = new win.XMLHttpRequest
 
-      return cy.route(opts).then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          status: 200,
-          url: /.*/,
-          originalUrl: "*",
-          response: {}
-        });
-      });
-    });
-
-    //# FIXME: I have no idea why this is skipped, this test is rly old
-    it.skip("can explicitly done() in onRequest function from options", done => cy
-      .server()
-      .route({
-        method: "POST",
-        url: "/users",
-        response: {},
-        onRequest() { return done(); }
+          xhr.open('GET', '/timeout?ms=100')
+          xhr.send()
+          xhrs.push(xhr)
+        })
       })
-      .then(() => cy.state("window").$.post("/users", "name=brian")));
+    })
 
-    it("can accept response as a function", function() {
-      const users = [{}, {}];
-      const getUsers = () => users;
+    it('has not aborted the xhrs', () => {
+      _.each(xhrs, (xhr) => {
+        expect(xhr.aborted).not.to.be.false
+      })
+    })
 
-      return cy.route(/users/, getUsers)
-      .then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          status: 200,
-          url: /users/,
-          response: users
-        });
-      });
-    });
+    it('aborts xhrs that haven\'t been sent', () => {
+      cy
+      .window()
+      .then((win) => {
+        const xhr = new win.XMLHttpRequest()
 
-    it("invokes response function with runnable.ctx", function() {
-      const ctx = this;
+        xhr.open('GET', '/timeout?ms=0')
+        xhr.abort()
 
-      const users = [{}, {}];
-      const getUsers = function() {
-        return expect(this === ctx).to.be.true;
-      };
+        expect(xhr.aborted).to.be.true
+      })
+    })
 
-      return cy.route(/users/, getUsers);
-    });
+    it('aborts xhrs currently in flight', () => {
+      let log = null
 
-    it("passes options as argument", function() {
-      const ctx = this;
+      cy.on('log:changed', (attrs, l) => {
+        if (attrs.name === 'xhr') {
+          if (!log) {
+            log = l
+          }
+        }
+      })
 
-      const users = [{}, {}];
-      const getUsers = function(opts) {
-        expect(opts).to.be.an("object");
-        return expect(opts.method).to.eq("GET");
-      };
+      cy
+      .window()
+      .then((win) => {
+        const xhr = new win.XMLHttpRequest()
 
-      return cy.route(/users/, getUsers);
-    });
+        xhr.open('GET', '/timeout?ms=999')
+        xhr.send()
+        xhr.abort()
 
-    it("can accept response as a function which returns a promise", function() {
-      const users = [{}, {}];
+        cy.wrap(null).should(() => {
+          expect(log.get('state')).to.eq('failed')
+          expect(log.invoke('renderProps')).to.deep.eq({
+            message: 'GET (aborted) /timeout?ms=999',
+            indicator: 'aborted',
+          })
 
-      const getUsers = () => new Promise((resolve, reject) => setTimeout(() => resolve(users)
-      , 10));
+          expect(xhr.aborted).to.be.true
+        })
+      })
+    })
 
-      return cy.route(/users/, getUsers)
-      .then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          status: 200,
-          url: /users/,
-          response: users
-        });
-      });
-    });
-
-    it("can accept a function which returns options", function() {
-      const users = [{}, {}];
-
-      const getRoute = () => ({
-        method: "GET",
-        url: /users/,
-        status: 201,
-        response() { return Promise.resolve(users); }
-      });
-
-      return cy.route(getRoute)
-      .then(function() {
-        return this.expectOptionsToBe({
-          method: "GET",
-          status: 201,
-          url: /users/,
-          response: users
-        });
-      });
-    });
+    // https://github.com/cypress-io/cypress/issues/3008
+    it('aborts xhrs even when responseType  not \'\' or \'text\'', () => {
+      let log = null
 
-    it("invokes route function with runnable.ctx", function() {
-      const ctx = this;
+      cy.on('log:changed', (attrs, l) => {
+        if (attrs.name === 'xhr') {
+          if (!log) {
+            log = l
+          }
+        }
+      })
 
-      const getUsers = function() {
-        expect(this === ctx).to.be.true;
+      cy
+      .window()
+      .then((win) => {
+        const xhr = new win.XMLHttpRequest()
 
-        return {
-          url: /foo/
-        };
-      };
-
-      return cy.route(getUsers);
-    });
-
-    //# FIXME: I have no idea why this is skipped, this test is rly old
-    it.skip("adds multiple routes to the responses array", () => cy
-      .route("foo", {})
-      .route("bar", {})
-      .then(() => expect(cy.state("sandbox").server.responses).to.have.length(2)));
-
-    it("can use regular strings as response", () => cy
-      .route("/foo", "foo bar baz").as("getFoo")
-      .window().then(function(win) {
-        win.$.get("/foo");
-        return null;}).wait("@getFoo").then(xhr => expect(xhr.responseBody).to.eq("foo bar baz")));
-
-    it("can stub requests with uncommon HTTP methods", () => cy
-      .route("PROPFIND", "/foo", "foo bar baz").as("getFoo")
-      .window().then(function(win) {
-        win.$.ajax({
-          url: "/foo",
-          method: "PROPFIND"
-        });
-        return null;}).wait("@getFoo").then(xhr => expect(xhr.responseBody).to.eq("foo bar baz")));
-
-    //# https://github.com/cypress-io/cypress/issues/2372
-    it("warns if a percent-encoded URL is used", function() {
-      cy.spy(Cypress.utils, 'warning');
-
-      return cy.route("GET", "/foo%25bar")
-      .then(() => expect(Cypress.utils.warning).to.be.calledWith(`\
-A \`url\` with percent-encoded characters was passed to \`cy.route()\`, but \`cy.route()\` expects a decoded \`url\`.
-
-Did you mean to pass "/foo%bar"?
-
-https://on.cypress.io/route\
-`
-      ));
-    });
-
-    it("does not warn if an invalid percent-encoded URL is used", function() {
-      cy.spy(Cypress.utils, 'warning');
-
-      return cy.route("GET", "http://example.com/%E0%A4%A")
-      .then(() => expect(Cypress.utils.warning).to.not.be.called);
-    });
-
-    //# FIXME: I have no idea why this is skipped, this test is rly old
-    it.skip("does not error when response is null but respond is false", () => cy.route({
-      url: /foo/,
-      respond: false
-    }));
-
-    describe("deprecations", function() {
-      beforeEach(function() {
-        return this.warn = cy.spy(window.top.console, "warn");
-      });
-
-      it("logs on {force404: false}", () => cy.server({force404: false})
-        .then(function() {
-          return expect(this.warn).to.be.calledWith("Cypress Warning: Passing `cy.server({force404: false})` is now the default behavior of `cy.server()`. You can safely remove this option.");
-      }));
-
-      it("does not log on {force404: true}", () => cy.server({force404: true})
-        .then(function() {
-          return expect(this.warn).not.to.be.called;
-      }));
-
-      return it("logs on {stub: false}", () => cy.server({stub: false})
-        .then(function() {
-          return expect(this.warn).to.be.calledWithMatch("Cypress Warning: Passing `cy.server({stub: false})` is now deprecated. You can safely remove: `{stub: false}`.\n\nhttps://on.cypress.io/deprecated-stub-false-on-server");
-      }));
-    });
-
-    describe("request response alias", function() {
-      it("matches xhrs with lowercase methods", () => cy
-        .route(/foo/, {}).as("getFoo")
-        .window().then(function(win) {
-          const xhr = new win.XMLHttpRequest;
-          xhr.open("get", "/foo");
-          return xhr.send();}).wait("@getFoo"));
-
-      it("can pass an alias reference to route", () => cy
-        .noop({foo: "bar"}).as("foo")
-        .route(/foo/, "@foo").as("getFoo")
-        .window().then(function(win) {
-          win.$.getJSON("foo");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          expect(xhr.responseBody).to.deep.eq({foo: "bar"});
-          return expect(xhr.responseBody).to.deep.eq(this.foo);
-      }));
-
-      it("can pass an alias when using a response function", function() {
-        const getFoo = () => Promise.resolve("@foo");
-
-        return cy
-          .noop({foo: "bar"}).as("foo")
-          .route(/foo/, getFoo).as("getFoo")
-          .window().then(function(win) {
-            win.$.getJSON("foo");
-            return null;}).wait("@getFoo").then(function(xhr) {
-            expect(xhr.responseBody).to.deep.eq({foo: "bar"});
-            return expect(xhr.responseBody).to.deep.eq(this.foo);
-        });
-      });
-
-      return it("can alias a route without stubbing it", () => cy
-        .route(/fixtures\/app/).as("getFoo")
-        .window().then(function(win) {
-          win.$.get("/fixtures/app.json");
-          return null;}).wait("@getFoo").then(function(xhr) {
-          const log = cy.queue.logs({name: "xhr"})[0];
-
-          expect(log.get("displayName")).to.eq("xhr");
-          expect(log.get("alias")).to.eq("getFoo");
-
-          return expect(xhr.responseBody).to.deep.eq({
-            some: "json",
-            foo: {
-              bar: "baz"
-            }
-          });
-      }));
-    });
+        xhr.responseType = 'arraybuffer'
+        xhr.open('GET', '/timeout?ms=1000')
+        xhr.send()
+        xhr.abort()
 
-    describe("response fixtures", function() {
-      it("works if the JSON file has an object", function() {
-        cy
-          .server()
-          .route({
-            method: 'POST',
-            url: '/test-xhr',
-            response: 'fixture:valid.json',
-          })
-          .visit('/fixtures/xhr-triggered.html')
-          .get('#trigger-xhr')
-          .click();
+        cy.wrap(null).should(() => {
+          expect(log.get('state')).to.eq('failed')
+          expect(xhr.aborted).to.be.true
+        })
+      })
+    })
 
-        return cy
-          .contains("#result", '{"foo":1,"bar":{"baz":"cypress"}}').should('be.visible');
-      });
+    // https://github.com/cypress-io/cypress/issues/1652
+    it('does not set aborted on XHR\'s that have completed by have had .abort() called', () => {
+      let log = null
 
-      return it("works if the JSON file has null content", function() {
-        cy
-          .server()
-          .route({
-            method: 'POST',
-            url: '/test-xhr',
-            response: 'fixture:null.json',
-          })
-          .visit('/fixtures/xhr-triggered.html')
-          .get('#trigger-xhr')
-          .click();
-
-        return cy
-          .contains('#result', '""').should('be.visible');
-      });
-    });
-
-    describe("errors", function() {
-      beforeEach(function() {
-        Cypress.config("defaultCommandTimeout", 100);
-
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          this.lastLog = log;
-          return this.logs.push(log);
-        });
-
-        return null;
-      });
-
-      it("throws if cy.server() hasnt been invoked", function(done) {
-        cy.state("serverIsStubbed", false);
-
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.route()` cannot be invoked before starting the `cy.server()`");
-          return done();
-        });
-
-        return cy.route();
-      });
-
-      it("url must be a string or regexp", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.route()` was called with an invalid `url`. `url` must be either a string or regular expression.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/route");
-          return done();
-        });
-
-        return cy.route({
-          url: {}
-        });
-      });
-
-      it("url must be a string or regexp when a function", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.route()` was called with an invalid `url`. `url` must be either a string or regular expression.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/route");
-          return done();
-        });
-
-        const getUrl = () => Promise.resolve({url: {}});
-
-        return cy.route(getUrl);
-      });
-
-      it("fails when functions reject", function(done) {
-        const error = new Error;
-
-        cy.on("fail", function(err) {
-          expect(err).to.eq(error);
-          return done();
-        });
-
-        const getUrl = () => Promise.reject(error);
-
-        return cy.route(getUrl);
-      });
-
-      it("fails when method is invalid", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.route()` was called with an invalid method: `POSTS`.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/route");
-
-          return done();
-        });
-
-        return cy.route("posts", "/foo", {});
-      });
-
-      it("requires a url when given a response", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.route()` must be called with a `url`. It can be a string or regular expression.");
-          return done();
-        });
-
-        return cy.route({});
-      });
-
-      _.each([null, undefined], function(val) {
-        it(`throws if response options was explicitly set to ${val}`, function(done) {
-          cy.on("fail", function(err) {
-            expect(err.message).to.include("`cy.route()` cannot accept an `undefined` or `null` response. It must be set to something, even an empty string will work.");
-            expect(err.docsUrl).to.eq("https://on.cypress.io/route");
-            return done();
-          });
-
-          return cy.route({url: /foo/, response: val});
-        });
-
-        return it(`throws if response argument was explicitly set to ${val}`, function(done) {
-          cy.on("fail", function(err) {
-            expect(err.message).to.include("`cy.route()` cannot accept an `undefined` or `null` response. It must be set to something, even an empty string will work.");
-            return done();
-          });
-
-          return cy.route(/foo/, val);
-        });
-      });
-
-      it("requires arguments", function(done) {
-        cy.on("fail", function(err) {
-          expect(err.message).to.include("`cy.route()` was not provided any arguments. You must provide valid arguments.");
-          expect(err.docsUrl).to.eq("https://on.cypress.io/route");
-          return done();
-        });
-
-        return cy.route();
-      });
-
-      it("sets err on log when caused by the XHR response", function(done) {
-        this.route.restore();
-
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          //# route + window + xhr log === 3
-          expect(this.logs.length).to.eq(3);
-          expect(lastLog.get("name")).to.eq("xhr");
-          expect(err).to.eq(lastLog.get("error"));
-          return done();
-        });
-
-        return cy
-          .route(/foo/, {}).as("getFoo")
-          .window().then(win => win.$.get("foo_bar").done(() => foo.bar()));
-      });
-
-      //# FIXME: I have no idea why this is skipped, this test is rly old
-      it.skip("explodes if response fixture signature errors", function(done) {
-        this.trigger = cy.stub(this.Cypress, "trigger").withArgs("fixture").callsArgWithAsync(2, {__error: "some error"});
-
-        const logs = [];
-
-        const _this = this;
-
-        //# we have to restore the trigger when commandErr is called
-        //# so that something logs out!
-        cy.commandErr = _.wrap(cy.commandErr, function(orig, err) {
-          _this.Cypress.trigger.restore();
-          return orig.call(this, err);
-        });
-
-        cy.on("log:added", (attrs, log) => {
-          this.log = log;
-          return logs.push(this.log);
-        });
-
-        cy.on("fail", err => {
-          expect(err.message).to.eq("some error");
-          expect(this.logs.length).to.eq(1);
-          expect(lastLog.get("name")).to.eq("route");
-          expect(lastLog.get("error")).to.eq(err);
-          expect(lastLog.get("message")).to.eq("/foo/, fixture:bar");
-          return done();
-        });
-
-        return cy
-          .route(/foo/, "fixture:bar");
-      });
-
-      //# TODO: handle this uncaught exception failure
-      it.skip("does not retry (cancels existing promise) when xhr errors", function(done) {
-        const cancel = cy.spy(Promise.prototype, "cancel");
-
-        cy.on("command:retry", () => {
-          if (cy.state("error")) {
-            return done("should have canceled and not retried after failing");
+      cy.on('log:changed', (attrs, l) => {
+        if (attrs.name === 'xhr') {
+          if (!log) {
+            log = l
           }
-        });
+        }
+      })
 
-        cy.on("fail", err => {
-          const p = cy.state("promise");
+      cy
+      .window()
+      .then((win) => {
+        return new Promise((resolve) => {
+          const xhr = new win.XMLHttpRequest()
 
-          return _.delay(() => {
-            expect(cancel).to.be.calledOn(p);
-            return done();
-          }
-          , 100);
-        });
+          xhr.open('GET', '/timeout?ms=0')
+          xhr.onload = function () {
+            xhr.abort()
+            xhr.foo = 'bar'
 
-        return cy
-          .route({
-            url: /foo/,
-            response: {},
-            delay: 100
-          })
-          .window().then(function(win) {
-            win.$.getJSON("/foo").done(function() {
-              throw new Error("foo failed");
-            });
-            return null;}).get("button").should("have.class", "does-not-exist");
-      });
-
-      return it("explodes if response alias cannot be found", function(done) {
-        cy.on("fail", err => {
-          const {
-            lastLog
-          } = this;
-
-          expect(this.logs.length).to.eq(2);
-          expect(err.message).to.eq("`cy.route()` could not find a registered alias for: `@bar`.\nAvailable aliases are: `foo`.");
-          expect(lastLog.get("name")).to.eq("route");
-          expect(lastLog.get("error")).to.eq(err);
-          expect(lastLog.get("message")).to.eq("/foo/, @bar");
-          return done();
-        });
-
-        return cy
-          .wrap({foo: "bar"}).as("foo")
-          .route(/foo/, "@bar");
-      });
-    });
-
-    return describe(".log", function() {
-      beforeEach(function() {
-        this.logs = [];
-
-        cy.on("log:added", (attrs, log) => {
-          if (attrs.instrument === "route") {
-            this.lastLog = log;
-            return this.logs.push(log);
+            return resolve(xhr)
           }
-        });
-
-        return null;
-      });
-
-      it("has name of route", () => cy.route("/foo", {}).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("name")).to.eq("route");
-      }));
-
-      it("uses the wildcard URL", () => cy.route("*", {}).then(function() {
-        const {
-          lastLog
-        } = this;
-
-        return expect(lastLog.get("url")).to.eq("*");
-      }));
-
-      it("#consoleProps", () => cy.route("*", {foo: "bar"}).as("foo").then(function() {
-        return expect(this.lastLog.invoke("consoleProps")).to.deep.eq({
-          Command: "route",
-          Method: "GET",
-          URL: "*",
-          Status: 200,
-          Response: {foo: "bar"},
-          Alias: "foo"
-          // Responded: 1 time
-          // "-------": ""
-          // Responses: []
-
-        });}));
-
-      return describe("numResponses", function() {
-        it("is initially 0", function() {
-          return cy.route(/foo/, {}).then(() => {
-            const {
-              lastLog
-            } = this;
-
-            return expect(lastLog.get("numResponses")).to.eq(0);
-          });
-        });
-
-        it("is incremented to 2", () => cy
-          .route(/foo/, {})
-          .window().then(win => win.$.get("/foo")).then(function() {
-            return expect(this.lastLog.get("numResponses")).to.eq(1);
-        }));
 
-        return it("is incremented for each matching request", () => cy
-          .route(/foo/, {})
-          .window().then(win => Promise.all([
-          win.$.get("/foo"),
-          win.$.get("/foo"),
-          win.$.get("/foo")
-        ])).then(function() {
-            return expect(this.lastLog.get("numResponses")).to.eq(3);
-        }));
-      });
-    });
-  });
-
-  context("consoleProps logs", function() {
-    beforeEach(function() {
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "xhr") {
-          this.lastLog = log;
-          return this.logs.push(log);
-        }
-      });
+          xhr.send()
+        })
+      })
+      .then((xhr) => {
+        cy
+        .wrap(null)
+        .should(() => {
+          // ensure this is set to prevent accidental
+          // race conditions down the road if something
+          // goes wrong
+          expect(xhr.foo).to.eq('bar')
+          expect(xhr.aborted).not.to.be.true
+          expect(log.get('state')).to.eq('passed')
+        })
+      })
+    })
+  })
 
-      return null;
-    });
+  context('Cypress.on(window:unload)', () => {
+    it('cancels all open XHR\'s', () => {
+      const xhrs = []
 
-    describe("when stubbed", () => it("says Stubbed: Yes", () => cy
-      .server()
-      .route(/foo/, {}).as("getFoo")
-      .window().then(win => new Promise(resolve => win.$.get("/foo").done(resolve))).then(function() {
-        return expect(this.lastLog.invoke("consoleProps").Stubbed).to.eq("Yes");
-    })));
-
-    describe("zero configuration / zero routes", function() {
-      beforeEach(() => cy
-        .server({force404: true})
-        .window().then(win => new Promise(resolve => win.$.ajax({
-        method: "POST",
-        url: "/foo",
-        data: JSON.stringify({foo: "bar"})
-      }).fail(() => resolve()))));
-
-      it("calculates duration", () => cy.then(function() {
-        const {
-          xhr
-        } = cy.state("responses")[0];
-
-        const consoleProps = this.lastLog.invoke("consoleProps");
-        expect(consoleProps.Duration).to.be.a("number");
-        expect(consoleProps.Duration).to.be.gt(1);
-        return expect(consoleProps.Duration).to.be.lt(1000);
-      }));
-
-      it("sends back regular 404", () => cy.then(function() {
-        const {
-          xhr
-        } = cy.state("responses")[0];
-
-        const consoleProps = _.pick(this.lastLog.invoke("consoleProps"), "Method", "Status", "URL", "XHR");
-        return expect(consoleProps).to.deep.eq({
-          Method: "POST",
-          Status: "404 (Not Found)",
-          URL: "http://localhost:3500/foo",
-          XHR: xhr.xhr
-        });
-      }));
-
-      return it("says Stubbed: Yes when sent 404 back", function() {
-        return expect(this.lastLog.invoke("consoleProps").Stubbed).to.eq("Yes");
-      });
-    });
-
-    describe("whitelisting", () => it("does not send back 404s on whitelisted routes", () => cy
+      cy
+      .window()
+      .then((win) => {
+        _.times(2, () => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('GET', '/timeout?ms=200')
+          xhr.send()
+          xhrs.push(xhr)
+        })
+      })
+      .reload()
+      .then(() => {
+        _.each(xhrs, (xhr) => {
+          expect(xhr.canceled).to.be.true
+        })
+      })
+    })
+  })
+
+  context('Cypress.on(window:before:load)', () => {
+    it('reapplies server + route automatically before window:load', () => {
+      // this tests that the server + routes are automatically reapplied
+      // after the 2nd visit - which is an example of the remote iframe
+      // causing an onBeforeLoad event
+      cy
       .server()
-      .window().then(win => win.$.get("/fixtures/app.js")).then(resp => expect(resp).to.eq("{ 'bar' }\n"))));
-
-    describe("route setup", function() {
-      beforeEach(() => cy
-        .server({force404: true})
-        .route("/foo", {}).as("anyRequest")
-        .window().then(function(win) {
-          win.$.get("/bar");
-          return null;
-      }));
-
-      return it("sends back 404 when request doesnt match route", () => cy.then(function() {
-        const consoleProps = this.lastLog.invoke("consoleProps");
-        return expect(consoleProps.Note).to.eq("This request did not match any of your routes. It was automatically sent back '404'. Setting cy.server({force404: false}) will turn off this behavior.");
-      }));
-    });
-
-    return describe("{force404: false}", function() {
-      beforeEach(() => cy
-        .server()
-        .window().then(win => win.$.getJSON("/fixtures/app.json")));
-
-      it("says Stubbed: No when request isnt forced 404", function() {
-        return expect(this.lastLog.invoke("consoleProps").Stubbed).to.eq("No");
-      });
-
-      it("logs request + response headers", () => cy.then(function() {
-        const consoleProps = this.lastLog.invoke("consoleProps");
-        expect(consoleProps.Request.headers).to.be.an("object");
-        return expect(consoleProps.Response.headers).to.be.an("object");
-      }));
-
-      it("logs Method, Status, URL, and XHR", () => cy.then(function() {
-        const {
-          xhr
-        } = cy.state("responses")[0];
-
-        const consoleProps = _.pick(this.lastLog.invoke("consoleProps"), "Method", "Status", "URL", "XHR");
-        return expect(consoleProps).to.deep.eq({
-          Method: "GET",
-          URL: "http://localhost:3500/fixtures/app.json",
-          Status: "200 (OK)",
-          XHR: xhr.xhr
-        });
-      }));
-
-      it("logs response", () => cy.then(function() {
-        const consoleProps = this.lastLog.invoke("consoleProps");
-        return expect(consoleProps.Response.body).to.deep.eq({
-          some: "json",
-          foo: {
-            bar: "baz"
-          }
-        });
-      }));
-
-      return it("sets groups Initiator", () => cy.then(function() {
-        const consoleProps = this.lastLog.invoke("consoleProps");
-
-        const group = consoleProps.groups()[0];
-        expect(group.name).to.eq("Initiator");
-        expect(group.label).to.be.false;
-        expect(group.items[0]).to.be.a("string");
-        return expect(group.items[0].split("\n").length).to.gt(1);
-      }));
-    });
-  });
-
-  context("renderProps", function() {
-    beforeEach(function() {
-      this.logs = [];
-
-      cy.on("log:added", (attrs, log) => {
-        if (attrs.name === "xhr") {
-          this.lastLog = log;
-          return this.logs.push(log);
-        }
-      });
+      .route(/foo/, { foo: 'bar' }).as('getFoo')
+      .visit('http://localhost:3500/fixtures/jquery.html')
+      .window().then((win) => {
+        return new Promise((resolve) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('GET', '/foo')
+          xhr.send()
+          xhr.onload = resolve
+        })
+      })
+      .wait('@getFoo').its('url').should('include', '/foo')
+      .visit('http://localhost:3500/fixtures/generic.html')
+      .window().then((win) => {
+        return new Promise((resolve) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('GET', '/foo')
+          xhr.send()
+          xhr.onload = resolve
+        })
+      })
+      .wait('@getFoo').its('url').should('include', '/foo')
+    })
 
-      return null;
-    });
+    it('reapplies server + route automatically during page transitions', () => {
+      // this tests that the server + routes are automatically reapplied
+      // after the 2nd visit - which is an example of the remote iframe
+      // causing an onBeforeLoad event
+      cy
+      .server()
+      .route(/foo/, { foo: 'bar' }).as('getFoo')
+      .visit('http://localhost:3500/fixtures/jquery.html')
+      .window().then((win) => {
+        const url = 'http://localhost:3500/fixtures/generic.html'
 
-    describe("in any case", function() {
-      beforeEach(() => cy
-        .server()
-        .route(/foo/, {})
-        .window().then(win => new Promise(resolve => win.$.get("/foo").done(resolve))));
+        const $a = win.$(`<a href='${url}'>jquery</a>`)
+        .appendTo(win.document.body)
 
-      return it("sends correct message", () => cy.then(function() {
-        return expect(this.lastLog.invoke("renderProps").message).to.equal("GET 200 /foo");
-      }));
-    });
+        // synchronous beforeunload
+        return $a.get(0).click()
+      })
+      .url().should('include', '/generic.html')
+      .window().then((win) => {
+        return new Promise((resolve) => {
+          const xhr = new win.XMLHttpRequest
+
+          xhr.open('GET', '/foo')
+          xhr.send()
+          xhr.onload = resolve
+        })
+      })
+      .wait('@getFoo').its('url').should('include', '/foo')
+    })
+  })
 
-    describe("when response is successful", function() {
-      beforeEach(() => cy
-        .server()
-        .route(/foo/, {})
-        .window().then(win => new Promise(resolve => win.$.get("/foo").done(resolve))));
+  // FIXME: I have no idea why this is skipped, this test is rly old
+  context.skip('#cancel', () => {
+    it('calls server#cancel', function (done) {
+      let cancel = null
 
-      return it("sends correct indicator", () => cy.then(function() {
-        return expect(this.lastLog.invoke("renderProps").indicator).to.equal("successful");
-      }));
-    });
+      this.Cypress.once('abort', () => {
+        expect(cancel).to.be.called
 
-    describe("when response is pending", function() {
-      beforeEach(() => cy
-        .server()
-        .route({ url: "/foo", delay: 500, response: {} })
-        .window().then(function(win) {
-          win.$.get("/foo");
-          return null;
-      }));
-
-      //# FAILING
-      it("sends correct message", function() {
-        return expect(this.lastLog.invoke("renderProps").message).to.equal("GET --- /foo");
-      });
-
-      return it("sends correct indicator", function() {
-        return expect(this.lastLog.invoke("renderProps").indicator).to.equal("pending");
-      });
-    });
-
-    return describe("when response is outside 200 range", function() {
-      beforeEach(() => cy
-        .server()
-        .route({ url: "/foo", status: 500, response: {} })
-        .window().then(win => new Promise(resolve => win.$.get("/foo").fail(() => resolve()))));
+        done()
+      })
 
-      return it("sends correct indicator", () => cy.then(function() {
-        return expect(this.lastLog.invoke("renderProps").indicator).to.equal("bad");
-      }));
-    });
-  });
+      cy.server().then(function () {
+        cancel = cy.spy(cy.state('server'), 'cancel')
 
-  context("abort", function() {
-    const xhrs = [];
+        this.Cypress.trigger('abort')
+      })
+    })
+  })
 
-    beforeEach(() => cy.visit("/fixtures/jquery.html"));
+  // FIXME: I have no idea why this is skipped, this test is rly old
+  context.skip('#respond', () => {
+    it('calls server#respond', () => {
+      let respond = null
 
-    it("does not abort xhr's between tests", () => cy.window().then(win => _.times(2, function() {
-      const xhr = new win.XMLHttpRequest;
-      xhr.open("GET", "/timeout?ms=100");
-      xhr.send();
+      cy
+      .server({ delay: 100 }).then((server) => {
+        respond = cy.spy(server, 'respond')
+      })
+      .window().then((win) => {
+        win.$.get('/users')
 
-      return xhrs.push(xhr);
-    })));
+        return null
+      })
+      .respond().then(() => {
+        expect(respond).to.be.calledOnce
+      })
+    })
 
-    it("has not aborted the xhrs", () => _.each(xhrs, xhr => expect(xhr.aborted).not.to.be.false));
+    describe('errors', () => {
+      beforeEach(function () {
+        this.allowErrors()
+      })
 
-    it("aborts xhrs that haven't been sent", () => cy
-    .window()
-    .then(function(win) {
-      const xhr = new win.XMLHttpRequest();
-      xhr.open("GET", "/timeout?ms=0");
-      xhr.abort();
+      it('errors without a server', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('cy.respond() cannot be invoked before starting the `cy.server()`')
 
-      return expect(xhr.aborted).to.be.true;
-    }));
+          done()
+        })
 
-    it("aborts xhrs currently in flight", function() {
-      let log = null;
+        cy.respond()
+      })
 
-      cy.on("log:changed", (attrs, l) => {
-        if (attrs.name === "xhr") {
-          if (!log) {
-            return log = l;
-          }
-        }
-      });
+      it('errors with no pending requests', (done) => {
+        cy.on('fail', (err) => {
+          expect(err.message).to.eq('cy.respond() did not find any pending requests to respond to')
 
-      return cy
-      .window()
-      .then(function(win) {
-        const xhr = new win.XMLHttpRequest();
-        xhr.open("GET", "/timeout?ms=999");
-        xhr.send();
-        xhr.abort();
-
-        return cy.wrap(null).should(function() {
-          expect(log.get("state")).to.eq("failed");
-          expect(log.invoke("renderProps")).to.deep.eq({
-            message: "GET (aborted) /timeout?ms=999",
-            indicator: 'aborted',
-          });
-          return expect(xhr.aborted).to.be.true;
-        });
-      });
-    });
-
-    //# https://github.com/cypress-io/cypress/issues/3008
-    it("aborts xhrs even when responseType  not '' or 'text'", function() {
-      let log = null;
-
-      cy.on("log:changed", (attrs, l) => {
-        if (attrs.name === "xhr") {
-          if (!log) {
-            return log = l;
-          }
-        }
-      });
+          done()
+        })
 
-      return cy
-      .window()
-      .then(function(win) {
-        const xhr = new win.XMLHttpRequest();
-        xhr.responseType = 'arraybuffer';
-        xhr.open("GET", "/timeout?ms=1000");
-        xhr.send();
-        xhr.abort();
-
-        return cy.wrap(null).should(function() {
-          expect(log.get("state")).to.eq("failed");
-          return expect(xhr.aborted).to.be.true;
-        });
-      });
-    });
-
-    //# https://github.com/cypress-io/cypress/issues/1652
-    return it("does not set aborted on XHR's that have completed by have had .abort() called", function() {
-      let log = null;
-
-      cy.on("log:changed", (attrs, l) => {
-        if (attrs.name === "xhr") {
-          if (!log) {
-            return log = l;
-          }
-        }
-      });
+        cy
+        .server()
+        .route(/users/, {})
+        .window().then((win) => {
+          // this is waited on to be resolved
+          // because of jquery promise thenable
+          return win.$.get('/users')
+        })
+        .respond()
+      })
+    })
+  })
 
-      return cy
-      .window()
-      .then(win => new Promise(function(resolve) {
-        const xhr = new win.XMLHttpRequest();
-        xhr.open("GET", "/timeout?ms=0");
-        xhr.onload = function() {
-          xhr.abort();
-          xhr.foo = "bar";
-          return resolve(xhr);
-        };
-        return xhr.send();
-      })).then(xhr => cy
-      .wrap(null)
-      .should(function() {
-        //# ensure this is set to prevent accidental
-        //# race conditions down the road if something
-        //# goes wrong
-        expect(xhr.foo).to.eq("bar");
-        expect(xhr.aborted).not.to.be.true;
-        return expect(log.get("state")).to.eq("passed");
-      }));
-    });
-  });
-
-  context("Cypress.on(window:unload)", () => it("cancels all open XHR's", function() {
-    const xhrs = [];
-
-    return cy
-    .window()
-    .then(win => _.times(2, function() {
-      const xhr = new win.XMLHttpRequest;
-      xhr.open("GET", "/timeout?ms=200");
-      xhr.send();
-
-      return xhrs.push(xhr);
-    })).reload()
-    .then(() => _.each(xhrs, xhr => expect(xhr.canceled).to.be.true));
-  }));
-
-  context("Cypress.on(window:before:load)", function() {
-    it("reapplies server + route automatically before window:load", () => //# this tests that the server + routes are automatically reapplied
-    //# after the 2nd visit - which is an example of the remote iframe
-    //# causing an onBeforeLoad event
-    cy
-      .server()
-      .route(/foo/, {foo: "bar"}).as("getFoo")
-      .visit("http://localhost:3500/fixtures/jquery.html")
-      .window().then(win => new Promise(function(resolve) {
-      const xhr = new win.XMLHttpRequest;
-      xhr.open("GET", "/foo");
-      xhr.send();
-      return xhr.onload = resolve;
-    })).wait("@getFoo").its("url").should("include", "/foo")
-      .visit("http://localhost:3500/fixtures/generic.html")
-      .window().then(win => new Promise(function(resolve) {
-      const xhr = new win.XMLHttpRequest;
-      xhr.open("GET", "/foo");
-      xhr.send();
-      return xhr.onload = resolve;
-    })).wait("@getFoo").its("url").should("include", "/foo"));
-
-    return it("reapplies server + route automatically during page transitions", () => //# this tests that the server + routes are automatically reapplied
-    //# after the 2nd visit - which is an example of the remote iframe
-    //# causing an onBeforeLoad event
-    cy
-      .server()
-      .route(/foo/, {foo: "bar"}).as("getFoo")
-      .visit("http://localhost:3500/fixtures/jquery.html")
-      .window().then(function(win) {
-        const url = "http://localhost:3500/fixtures/generic.html";
+  context('options immutability', () => {
+    it('does not mutate options for cy.server()', () => {
+      const options = { enable: false }
 
-        const $a = win.$(`<a href='${url}'>jquery</a>`)
-        .appendTo(win.document.body);
-
-        //# synchronous beforeunload
-        return $a.get(0).click();}).url().should("include", "/generic.html")
-      .window().then(win => new Promise(function(resolve) {
-      const xhr = new win.XMLHttpRequest;
-      xhr.open("GET", "/foo");
-      xhr.send();
-      return xhr.onload = resolve;
-    })).wait("@getFoo").its("url").should("include", "/foo"));
-  });
-
-  //# FIXME: I have no idea why this is skipped, this test is rly old
-  context.skip("#cancel", () => it("calls server#cancel", function(done) {
-    let cancel = null;
-
-    this.Cypress.once("abort", function() {
-      expect(cancel).to.be.called;
-      return done();
-    });
-
-    return cy.server().then(function() {
-      cancel = cy.spy(cy.state("server"), "cancel");
-      return this.Cypress.trigger("abort");
-    });
-  }));
-
-  //# FIXME: I have no idea why this is skipped, this test is rly old
-  context.skip("#respond", function() {
-    it("calls server#respond", function() {
-      let respond = null;
-
-      return cy
-        .server({delay: 100}).then(server => respond = cy.spy(server, "respond")).window().then(function(win) {
-          win.$.get("/users");
-          return null;}).respond().then(() => expect(respond).to.be.calledOnce);
-    });
-
-    return describe("errors", function() {
-      beforeEach(function() {
-        return this.allowErrors();
-      });
-
-      it("errors without a server", function(done) {
-        cy.on("fail", err => {
-          expect(err.message).to.eq("cy.respond() cannot be invoked before starting the `cy.server()`");
-          return done();
-        });
-
-        return cy.respond();
-      });
-
-      return it("errors with no pending requests", function(done) {
-        cy.on("fail", err => {
-          expect(err.message).to.eq("cy.respond() did not find any pending requests to respond to");
-          return done();
-        });
-
-        return cy
-          .server()
-          .route(/users/, {})
-          .window().then(win => //# this is waited on to be resolved
-        //# because of jquery promise thenable
-        win.$.get("/users")).respond();
-      });
-    });
-  });
-
-      //# currently this does not fail. we'll wait until someone cares
-      // it "errors if response was null or undefined", (done) ->
-      //   cy.on "fail", (err) ->
-
-      //   cy
-      //     .server()
-      //     .route({
-      //       url: /foo/
-      //       respond: false
-      //     })
-      //     .window().then (win) ->
-      //       win.$.get("/foo")
-      //       null
-      //     .respond()
-
-  return context("options immutability", function() {
-    it("does not mutate options for cy.server()", function() {
-      const options = { enable: false };
-
-      return cy
+      cy
       .server(options)
-      .window().then(() => expect(options).to.deep.eq({ enable: false }));
-    });
+      .window().then(() => {
+        expect(options).to.deep.eq({ enable: false })
+      })
+    })
 
-    return it("does not mutate options for cy.route()", function() {
+    it('does not mutate options for cy.route()', () => {
       const options = {
         url: /foo/,
-        respond: false
-      };
+        respond: false,
+      }
 
-      return cy
+      cy
       .server()
       .route(options)
-      .window().then(() => expect(options).to.deep.eq({
-        url: /foo/,
-        respond: false
-      }));
-    });
-  });
-});
-
-function __range__(left, right, inclusive) {
-  let range = [];
-  let ascending = left < right;
-  let end = !inclusive ? right : ascending ? right + 1 : right - 1;
-  for (let i = left; ascending ? i < end : i > end; ascending ? i++ : i--) {
-    range.push(i);
-  }
-  return range;
-}
\ No newline at end of file
+      .window().then(() => {
+        expect(options).to.deep.eq({
+          url: /foo/,
+          respond: false,
+        })
+      })
+    })
+  })
+})
diff --git a/packages/server/__snapshots__/4_request_spec.coffee.js b/packages/server/__snapshots__/4_request_spec.coffee.js
index b3ffbd1b9c74..58082fd8e0e7 100644
--- a/packages/server/__snapshots__/4_request_spec.coffee.js
+++ b/packages/server/__snapshots__/4_request_spec.coffee.js
@@ -246,7 +246,6 @@ Headers: {
 }
 Body: Service Unavailable
 
-
 https://on.cypress.io/request
       [stack trace lines]
 
@@ -374,6 +373,7 @@ Body: <!DOCTYPE html>
 </body>
 </html>
 
+
 https://on.cypress.io/request
       [stack trace lines]