Add new event 'page:error'

.eslintignore

@@ -1,5 +1,5 @@
 __snapshots__
-packages/server/lib/scaffold/plugins/index.js
+packages/server/lib/scaffold/background/index.js
 packages/server/lib/scaffold/support/index.js
 packages/server/lib/scaffold/support/commands.js
 packages/server/test/fixtures

circle.yml

@@ -717,6 +717,9 @@ linux-workflow: &linux-workflow
     - desktop-gui-integration-tests-2x:
         requires:
           - build
+    - reporter-integration-tests:
+        requires:
+          - build
     - run-launcher:
         requires:
           - build

cli/schema/cypress.schema.json

@@ -84,10 +84,10 @@
       "default": "cypress/integration",
       "description": "Path to folder containing integration test files"
     },
-    "pluginsFile": {
+    "backgroundFile": {
       "type": ["string", "boolean"],
-      "default": "cypress/plugins/index.js",
-      "description": "Path to plugins file. (Pass false to disable)"
+      "default": "cypress/background/index.js",
+      "description": "Path to background file. (Pass false to disable)"
     },
     "screenshotsFolder": {
       "type": "string",

cli/test/lib/tasks/cache_spec.js

@@ -40,9 +40,12 @@ describe('lib/tasks/cache', () => {
   describe('.clear', () => {
     it('deletes cache folder and everything inside it', () => {
       return cache.clear()
-      .then(() =>
-        fs.pathExistsAsync('/.cache/Cypress')
-        .then((exists) => expect(exists).to.eql(false))
+      .then(() => {
+        return fs.pathExistsAsync('/.cache/Cypress')
+        .then((exists) => {
+          return expect(exists).to.eql(false)
+        })
+      }
       )
     })
   })

cli/types/index.d.ts

@@ -1931,10 +1931,10 @@ declare namespace Cypress {
      */
     integrationFolder: string
     /**
-     * Path to plugins file. (Pass false to disable)
-     * @default "cypress/plugins/index.js"
+     * Path to background file. (Pass false to disable)
+     * @default "cypress/background/index.js"
      */
-    pluginsFile: string
+    backgroundFile: string
     /**
      * Path to folder where screenshots will be saved from [cy.screenshot()](https://on.cypress.io/screenshot) command or after a headless or CI run’s test failure
      * @default "cypress/screenshots"
@@ -2163,14 +2163,14 @@ declare namespace Cypress {
      *
      * @param {Window} contentWindow the remote page's window object
      */
-    onBeforeLoad(win: Window): void
+    onStart(win: Window): void
 
     /**
      * Called once your page has fired its load event.
      *
      * @param {Window} contentWindow the remote page's window object
      */
-    onLoad(win: Window): void
+    onReady(win: Window): void
 
     /**
      * Whether to fail on response codes other than 2xx and 3xx
@@ -3803,7 +3803,24 @@ declare namespace Cypress {
     (fn: (currentSubject: Subject) => void): Chainable<Subject>
   }
 
-  // for just a few events like "window:alert" it makes sense to allow passing cy.stub() or
+  /**
+   * Page details included with actions like 'page:start'
+   */
+  interface PageDetails {
+    win: Window
+    url: string
+    statusCode?: number
+    headers?: { [key: string]: string }
+  }
+
+  /**
+   * Error augmented with source property to indicate its origin
+   */
+  interface PageError extends Error {
+    source: 'onerror' | 'onunhandledrejection'
+  }
+
+  // for just a few events like "page:alert" it makes sense to allow passing cy.stub() or
   // a user callback function. Others probably only need a callback function.
 
   /**
@@ -3823,43 +3840,43 @@ declare namespace Cypress {
       // so it's applied to all spec files
       // cypress/support/index.js
 
-      Cypress.on('uncaught:exception', (err, runnable) => {
+      Cypress.on('page:error', (err, runnable) => {
         // returning false here prevents Cypress from
         // failing the test
         return false
       })
       // stub "window.alert" in a single test
       it('shows alert', () => {
         const stub = cy.stub()
-        cy.on('window:alert', stub)
+        cy.on('page:alert', stub)
         // trigger application code that calls alert(...)
         .then(() => {
           expect(stub).to.have.been.calledOnce
         })
       })
     ```
      */
-    (action: 'uncaught:exception', fn: (error: Error, runnable: Mocha.IRunnable) => false | void): void
+    (action: 'page:error', fn: (error: PageError, runnable: Mocha.IRunnable) => false | void): void
     /**
      * Fires when your app calls the global `window.confirm()` method.
      * Cypress will auto accept confirmations. Return `false` from this event and the confirmation will be cancelled.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      * @example
     ```
-    cy.on('window:confirm', (str) => {
+    cy.on('page:confirm', (str) => {
       console.log(str)
       return false // simulate "Cancel"
     })
     ```
      */
-    (action: 'window:confirm', fn: ((text: string) => false | void) | Agent<sinon.SinonSpy>): void
+    (action: 'page:confirm', fn: ((text: string) => false | void) | Agent<sinon.SinonSpy>): void
     /**
      * Fires when your app calls the global `window.alert()` method.
      * Cypress will auto accept alerts. You cannot change this behavior.
      * @example
     ```
     const stub = cy.stub()
-    cy.on('window:alert', stub)
+    cy.on('page:alert', stub)
     // assume the button calls window.alert()
     cy.get('.my-button')
       .click()
@@ -3869,67 +3886,67 @@ declare namespace Cypress {
     ```
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:alert', fn: ((text: string) => void) | Agent<sinon.SinonSpy>): void
+    (action: 'page:alert', fn: ((text: string) => void) | Agent<sinon.SinonSpy>): void
     /**
-     * Fires as the page begins to load, but before any of your applications JavaScript has executed. This fires at the exact same time as `cy.visit()` `onBeforeLoad` callback. Useful to modify the window on a page transition.
+     * Fires as the page begins to load, but before any of your applications JavaScript has executed. This fires at the exact same time as `cy.visit()` `onStart` callback. Useful to modify the window on a page transition.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:before:load', fn: (win: Window) => void): void
+    (action: 'page:start', fn: (details: PageDetails) => void): void
     /**
-     * Fires after all your resources have finished loading after a page transition. This fires at the exact same time as a `cy.visit()` `onLoad` callback.
+     * Fires after all your resources have finished loading after a page transition. This fires at the exact same time as a `cy.visit()` `onReady` callback.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:load', fn: (win: Window) => void): void
+    (action: 'page:ready', fn: (details: PageDetails) => void): void
     /**
-     * Fires when your application is about to navigate away. The real event object is provided to you. Your app may have set a `returnValue` on the event, which is useful to assert on.
+     * Fires when your application is has unloaded and is navigating away. The real event object is provided to you. This event is not cancelable.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:before:unload', fn: (event: BeforeUnloadEvent) => void): void
+    (action: 'page:end', fn: (details: PageDetails) => void): void
     /**
-     * Fires when your application is has unloaded and is navigating away. The real event object is provided to you. This event is not cancelable.
+     * Fires when your application is about to navigate away. The real event object is provided to you. Your app may have set a `returnValue` on the event, which is useful to assert on.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'window:unload', fn: (event: Event) => void): void
+    (action: 'before:window:unload', fn: (event: BeforeUnloadEvent) => void): void
     /**
      * Fires whenever Cypress detects that your application's URL has changed.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'url:changed', fn: (url: string) => void): void
+    (action: 'page:url:changed', fn: (url: string) => void): void
     /**
      * Fires when the test has failed. It is technically possible to prevent the test from actually failing by binding to this event and invoking an async `done` callback. However this is **strongly discouraged**. Tests should never legitimately fail. This event exists because it's extremely useful for debugging purposes.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'fail', fn: (error: Error, mocha: Mocha.IRunnable) => void): void
+    (action: 'test:fail', fn: (error: Error, mocha: Mocha.IRunnable) => void): void
     /**
      * Fires whenever the viewport changes via a `cy.viewport()` or naturally when Cypress resets the viewport to the default between tests. Useful for debugging purposes.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'viewport:changed', fn: (viewport: Viewport) => void): void
+    (action: 'viewport:change', fn: (viewport: Viewport) => void): void
     /**
      * Fires whenever **Cypress** is scrolling your application. This event is fired when Cypress is {% url 'waiting for and calculating actionability' interacting-with-elements %}. It will scroll to 'uncover' elements currently being covered. This event is extremely useful to debug why Cypress may think an element is not interactive.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'scrolled', fn: ($el: JQuery) => void): void
+    (action: 'internal:scrolled', fn: ($el: JQuery) => void): void
     /**
      * Fires when a cy command is first invoked and enqueued to be run later. Useful for debugging purposes if you're confused about the order in which commands will execute.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'command:enqueued', fn: (command: EnqueuedCommand) => void): void
+    (action: 'internal:commandEnqueue', fn: (command: EnqueuedCommand) => void): void
     /**
      * Fires when cy begins actually running and executing your command. Useful for debugging and understanding how the command queue is async.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'command:start', fn: (command: CommandQueue) => void): void
+    (action: 'internal:commandStart', fn: (command: CommandQueue) => void): void
     /**
      * Fires when cy finishes running and executing your command. Useful for debugging and understanding how commands are handled.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'command:end', fn: (command: CommandQueue) => void): void
+    (action: 'internal:commandEnd', fn: (command: CommandQueue) => void): void
     /**
      * Fires whenever a command begins its retrying routines. This is called on the trailing edge after Cypress has internally waited for the retry interval. Useful to understand **why** a command is retrying, and generally includes the actual error causing the retry to happen. When commands fail the final error is the one that actually bubbles up to fail the test. This event is essentially to debug why Cypress is failing.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'command:retry', fn: (command: CommandQueue) => void): void
+    (action: 'internal:commandRetry', fn: (command: CommandQueue) => void): void
     /**
      * Fires whenever a command emits this event so it can be displayed in the Command Log. Useful to see how internal cypress commands utilize the {% url 'Cypress.log()' cypress-log %} API.
      * @see https://on.cypress.io/catalog-of-events#App-Events
@@ -3944,12 +3961,12 @@ declare namespace Cypress {
      * Fires before the test and all **before** and **beforeEach** hooks run.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'test:before:run', fn: (attributes: ObjectLike, test: Mocha.ITest) => void): void
+    (action: 'test:start', fn: (attributes: ObjectLike, test: Mocha.ITest) => void): void
     /**
      * Fires after the test and all **afterEach** and **after** hooks run.
      * @see https://on.cypress.io/catalog-of-events#App-Events
      */
-    (action: 'test:after:run', fn: (attributes: ObjectLike, test: Mocha.ITest) => void): void
+    (action: 'test:end', fn: (attributes: ObjectLike, test: Mocha.ITest) => void): void
   }
 
   // $CommandQueue from `command_queue.coffee` - a lot to type. Might be more useful if it was written in TS

cli/types/tests/actions.ts

@@ -1,62 +1,62 @@
-Cypress.on('uncaught:exception', (error, runnable) => {
-  error // $ExpectType Error
+Cypress.on('page:error', (error, runnable) => {
+  error // $ExpectType PageError
   runnable // $ExpectType IRunnable
 })
 
-Cypress.on('window:confirm', (text) => {
+Cypress.on('page:confirm', (text) => {
   text // $ExpectType string
 })
 
-Cypress.on('window:alert', (text) => {
+Cypress.on('page:alert', (text) => {
   text // $ExpectType string
 })
 
-Cypress.on('window:before:load', (win) => {
-  win // $ExpectType Window
+Cypress.on('page:start', (details) => {
+  details // $ExpectType PageDetails
 })
 
-Cypress.on('window:load', (win) => {
-  win // $ExpectType Window
+Cypress.on('page:ready', (details) => {
+  details // $ExpectType PageDetails
 })
 
-Cypress.on('window:before:unload', (event) => {
-  event // $ExpectType BeforeUnloadEvent
+Cypress.on('page:end', (details) => {
+  details // $ExpectType PageDetails
 })
 
-Cypress.on('window:unload', (event) => {
-  event // $ExpectType Event
+Cypress.on('before:window:unload', (event) => {
+  event // $ExpectType BeforeUnloadEvent
 })
 
-Cypress.on('url:changed', (url) => {
+Cypress.on('page:url:changed', (url) => {
   url // $ExpectType string
 })
 
-Cypress.on('fail', (error, mocha) => {
+Cypress.on('test:fail', (error, mocha) => {
   error // $ExpectType Error
   mocha // $ExpectType IRunnable
 })
 
-Cypress.on('viewport:changed', (viewport) => {
+Cypress.on('viewport:change', (viewport) => {
   viewport // $ExpectType Viewport
 })
 
-Cypress.on('scrolled', ($el) => {
+Cypress.on('internal:scrolled', ($el) => {
   $el // $ExpectType JQuery<HTMLElement>
 })
 
-Cypress.on('command:enqueued', (command) => {
+Cypress.on('internal:commandEnqueue', (command) => {
   command // $ExpectType EnqueuedCommand
 })
 
-Cypress.on('command:start', (command) => {
+Cypress.on('internal:commandStart', (command) => {
   command // $ExpectType CommandQueue
 })
 
-Cypress.on('command:end', (command) => {
+Cypress.on('internal:commandEnd', (command) => {
   command // $ExpectType CommandQueue
 })
 
-Cypress.on('command:retry', (command) => {
+Cypress.on('internal:commandRetry', (command) => {
   command // $ExpectType CommandQueue
 })
 
@@ -68,12 +68,12 @@ Cypress.on('log:changed', (log, interactive: boolean) => {
   log // $ExpectTyped any
 })
 
-Cypress.on('test:before:run', (attributes , test) => {
+Cypress.on('test:start', (attributes , test) => {
   attributes // $ExpectType ObjectLike
   test // $ExpectType ITest
 })
 
-Cypress.on('test:after:run', (attributes , test) => {
+Cypress.on('test:end', (attributes , test) => {
   attributes // $ExpectType ObjectLike
   test // $ExpectType ITest
 })

cli/types/tests/cypress-tests.ts

@@ -212,25 +212,25 @@ cy
   })
 
 namespace CypressOnTests {
-  Cypress.on('uncaught:exception', (error, runnable) => {
-    error // $ExpectType Error
+  Cypress.on('page:error', (error, runnable) => {
+    error // $ExpectType PageError
     runnable // $ExpectType IRunnable
   })
 
-  cy.on('uncaught:exception', (error, runnable) => {
-    error // $ExpectType Error
+  cy.on('page:error', (error, runnable) => {
+    error // $ExpectType PageError
     runnable // $ExpectType IRunnable
   })
 }
 
 namespace CypressOffTests {
-  Cypress.off('uncaught:exception', (error, runnable) => {
-    error // $ExpectType Error
+  Cypress.off('page:error', (error, runnable) => {
+    error // $ExpectType PageError
     runnable // $ExpectType IRunnable
   })
 
-  cy.off('uncaught:exception', (error, runnable) => {
-    error // $ExpectType Error
+  cy.off('page:error', (error, runnable) => {
+    error // $ExpectType PageError
     runnable // $ExpectType IRunnable
   })
 }